blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 5
146
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
7
| license_type
stringclasses 2
values | repo_name
stringlengths 6
79
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 4
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.07k
426M
⌀ | star_events_count
int64 0
27
| fork_events_count
int64 0
12
| gha_license_id
stringclasses 3
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 6
values | src_encoding
stringclasses 26
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 1
class | length_bytes
int64 20
6.28M
| extension
stringclasses 20
values | content
stringlengths 20
6.28M
| authors
listlengths 1
16
| author_lines
listlengths 1
16
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
caa6fc684544e889d7ee78fae3ac6ce5791c087f | 9e00e3827904177e7ae74a95c2b4694b39a35aca | /tests/src/test_mark_sweep_pin.cpp | cbda1269020c5ca53c41f2ba3c885c44832ca43f | [] | no_license | windreamer/cppgc | 398dbfdd5c5c73138799932f67347fe35440d1e5 | 9df085aaca78d28538853cc1a50326177c4c5ef0 | refs/heads/master | 2016-09-06T09:01:56.106376 | 2010-12-14T04:44:19 | 2010-12-14T04:44:19 | 1,290,072 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 861 | cpp | #include <tut/tut.hpp>
#include "algorithm/mark_sweep.h"
#include "gc.h"
using namespace windreamer::gc;
namespace tut
{
typedef GarbageCollector<algorithm::MarkSweep<> > GC;
struct MarksweepPinTestData
{
static bool exists;
struct existing
{
existing()
{
exists=true;
}
~existing()
{
exists=false;
}
};
};
bool MarksweepPinTestData::exists=false;
typedef test_group<MarksweepPinTestData> testGroup;
typedef testGroup::object object;
testGroup marksweeppinGroup("test_mark_sweep_pin");
template<>
template<>
void object::test<1>()
{
{
GC::Handle<existing> h=new GC::Wrapper<existing>();
GC::Handle<existing>::Pin pin(h);
GC::Controller::forceGC();
ensure_equals(exists,true);
}
GC::Controller::forceGC();
ensure_equals(exists,false);
}
}
| [
"[email protected]"
] | [
[
[
1,
48
]
]
] |
286d7735534d519a1f9b3367d1ea5d9ed44190fb | eb8a27a2cc7307f0bc9596faa4aa4a716676c5c5 | /WinEdition/browser-lcc/jscc/src/v8/v8/src/ast.cc | a72802c89d1df2645f36144bba65bdbb67d5bac0 | [
"BSD-3-Clause",
"bzip2-1.0.6",
"LicenseRef-scancode-public-domain",
"Artistic-2.0",
"Artistic-1.0"
] | permissive | baxtree/OKBuzzer | c46c7f271a26be13adcf874d77a7a6762a8dc6be | a16e2baad145f5c65052cdc7c767e78cdfee1181 | refs/heads/master | 2021-01-02T22:17:34.168564 | 2011-06-15T02:29:56 | 2011-06-15T02:29:56 | 1,790,181 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 32,757 | cc | // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "v8.h"
#include "ast.h"
#include "parser.h"
#include "scopes.h"
#include "string-stream.h"
#include "type-info.h"
namespace v8 {
namespace internal {
AstSentinels::AstSentinels()
: this_proxy_(true),
identifier_proxy_(false),
valid_left_hand_side_sentinel_(),
this_property_(&this_proxy_, NULL, 0),
call_sentinel_(NULL, NULL, 0) {
}
// ----------------------------------------------------------------------------
// All the Accept member functions for each syntax tree node type.
void Slot::Accept(AstVisitor* v) { v->VisitSlot(this); }
#define DECL_ACCEPT(type) \
void type::Accept(AstVisitor* v) { v->Visit##type(this); }
AST_NODE_LIST(DECL_ACCEPT)
#undef DECL_ACCEPT
// ----------------------------------------------------------------------------
// Implementation of other node functionality.
Assignment* ExpressionStatement::StatementAsSimpleAssignment() {
return (expression()->AsAssignment() != NULL &&
!expression()->AsAssignment()->is_compound())
? expression()->AsAssignment()
: NULL;
}
CountOperation* ExpressionStatement::StatementAsCountOperation() {
return expression()->AsCountOperation();
}
VariableProxy::VariableProxy(Variable* var)
: name_(var->name()),
var_(NULL), // Will be set by the call to BindTo.
is_this_(var->is_this()),
inside_with_(false),
is_trivial_(false),
position_(RelocInfo::kNoPosition) {
BindTo(var);
}
VariableProxy::VariableProxy(Handle<String> name,
bool is_this,
bool inside_with,
int position)
: name_(name),
var_(NULL),
is_this_(is_this),
inside_with_(inside_with),
is_trivial_(false),
position_(position) {
// Names must be canonicalized for fast equality checks.
ASSERT(name->IsSymbol());
}
VariableProxy::VariableProxy(bool is_this)
: var_(NULL),
is_this_(is_this),
inside_with_(false),
is_trivial_(false) {
}
void VariableProxy::BindTo(Variable* var) {
ASSERT(var_ == NULL); // must be bound only once
ASSERT(var != NULL); // must bind
ASSERT((is_this() && var->is_this()) || name_.is_identical_to(var->name()));
// Ideally CONST-ness should match. However, this is very hard to achieve
// because we don't know the exact semantics of conflicting (const and
// non-const) multiple variable declarations, const vars introduced via
// eval() etc. Const-ness and variable declarations are a complete mess
// in JS. Sigh...
var_ = var;
var->set_is_used(true);
}
Assignment::Assignment(Token::Value op,
Expression* target,
Expression* value,
int pos)
: op_(op),
target_(target),
value_(value),
pos_(pos),
binary_operation_(NULL),
compound_load_id_(kNoNumber),
assignment_id_(GetNextId()),
block_start_(false),
block_end_(false),
is_monomorphic_(false),
receiver_types_(NULL) {
ASSERT(Token::IsAssignmentOp(op));
if (is_compound()) {
binary_operation_ =
new BinaryOperation(binary_op(), target, value, pos + 1);
compound_load_id_ = GetNextId();
}
}
Token::Value Assignment::binary_op() const {
switch (op_) {
case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
case Token::ASSIGN_BIT_AND: return Token::BIT_AND;
case Token::ASSIGN_SHL: return Token::SHL;
case Token::ASSIGN_SAR: return Token::SAR;
case Token::ASSIGN_SHR: return Token::SHR;
case Token::ASSIGN_ADD: return Token::ADD;
case Token::ASSIGN_SUB: return Token::SUB;
case Token::ASSIGN_MUL: return Token::MUL;
case Token::ASSIGN_DIV: return Token::DIV;
case Token::ASSIGN_MOD: return Token::MOD;
default: UNREACHABLE();
}
return Token::ILLEGAL;
}
bool FunctionLiteral::AllowsLazyCompilation() {
return scope()->AllowsLazyCompilation();
}
ObjectLiteral::Property::Property(Literal* key, Expression* value) {
emit_store_ = true;
key_ = key;
value_ = value;
Object* k = *key->handle();
if (k->IsSymbol() && HEAP->Proto_symbol()->Equals(String::cast(k))) {
kind_ = PROTOTYPE;
} else if (value_->AsMaterializedLiteral() != NULL) {
kind_ = MATERIALIZED_LITERAL;
} else if (value_->AsLiteral() != NULL) {
kind_ = CONSTANT;
} else {
kind_ = COMPUTED;
}
}
ObjectLiteral::Property::Property(bool is_getter, FunctionLiteral* value) {
emit_store_ = true;
key_ = new Literal(value->name());
value_ = value;
kind_ = is_getter ? GETTER : SETTER;
}
bool ObjectLiteral::Property::IsCompileTimeValue() {
return kind_ == CONSTANT ||
(kind_ == MATERIALIZED_LITERAL &&
CompileTimeValue::IsCompileTimeValue(value_));
}
void ObjectLiteral::Property::set_emit_store(bool emit_store) {
emit_store_ = emit_store;
}
bool ObjectLiteral::Property::emit_store() {
return emit_store_;
}
bool IsEqualString(void* first, void* second) {
ASSERT((*reinterpret_cast<String**>(first))->IsString());
ASSERT((*reinterpret_cast<String**>(second))->IsString());
Handle<String> h1(reinterpret_cast<String**>(first));
Handle<String> h2(reinterpret_cast<String**>(second));
return (*h1)->Equals(*h2);
}
bool IsEqualNumber(void* first, void* second) {
ASSERT((*reinterpret_cast<Object**>(first))->IsNumber());
ASSERT((*reinterpret_cast<Object**>(second))->IsNumber());
Handle<Object> h1(reinterpret_cast<Object**>(first));
Handle<Object> h2(reinterpret_cast<Object**>(second));
if (h1->IsSmi()) {
return h2->IsSmi() && *h1 == *h2;
}
if (h2->IsSmi()) return false;
Handle<HeapNumber> n1 = Handle<HeapNumber>::cast(h1);
Handle<HeapNumber> n2 = Handle<HeapNumber>::cast(h2);
ASSERT(isfinite(n1->value()));
ASSERT(isfinite(n2->value()));
return n1->value() == n2->value();
}
void ObjectLiteral::CalculateEmitStore() {
HashMap properties(&IsEqualString);
HashMap elements(&IsEqualNumber);
for (int i = this->properties()->length() - 1; i >= 0; i--) {
ObjectLiteral::Property* property = this->properties()->at(i);
Literal* literal = property->key();
Handle<Object> handle = literal->handle();
if (handle->IsNull()) {
continue;
}
uint32_t hash;
HashMap* table;
void* key;
Factory* factory = Isolate::Current()->factory();
if (handle->IsSymbol()) {
Handle<String> name(String::cast(*handle));
if (name->AsArrayIndex(&hash)) {
Handle<Object> key_handle = factory->NewNumberFromUint(hash);
key = key_handle.location();
table = &elements;
} else {
key = name.location();
hash = name->Hash();
table = &properties;
}
} else if (handle->ToArrayIndex(&hash)) {
key = handle.location();
table = &elements;
} else {
ASSERT(handle->IsNumber());
double num = handle->Number();
char arr[100];
Vector<char> buffer(arr, ARRAY_SIZE(arr));
const char* str = DoubleToCString(num, buffer);
Handle<String> name = factory->NewStringFromAscii(CStrVector(str));
key = name.location();
hash = name->Hash();
table = &properties;
}
// If the key of a computed property is in the table, do not emit
// a store for the property later.
if (property->kind() == ObjectLiteral::Property::COMPUTED) {
if (table->Lookup(key, hash, false) != NULL) {
property->set_emit_store(false);
}
}
// Add key to the table.
table->Lookup(key, hash, true);
}
}
void TargetCollector::AddTarget(Label* target) {
// Add the label to the collector, but discard duplicates.
int length = targets_->length();
for (int i = 0; i < length; i++) {
if (targets_->at(i) == target) return;
}
targets_->Add(target);
}
bool UnaryOperation::ResultOverwriteAllowed() {
switch (op_) {
case Token::BIT_NOT:
case Token::SUB:
return true;
default:
return false;
}
}
bool BinaryOperation::ResultOverwriteAllowed() {
switch (op_) {
case Token::COMMA:
case Token::OR:
case Token::AND:
return false;
case Token::BIT_OR:
case Token::BIT_XOR:
case Token::BIT_AND:
case Token::SHL:
case Token::SAR:
case Token::SHR:
case Token::ADD:
case Token::SUB:
case Token::MUL:
case Token::DIV:
case Token::MOD:
return true;
default:
UNREACHABLE();
}
return false;
}
// ----------------------------------------------------------------------------
// Inlining support
bool Declaration::IsInlineable() const {
UNREACHABLE();
return false;
}
bool TargetCollector::IsInlineable() const {
UNREACHABLE();
return false;
}
bool Slot::IsInlineable() const {
UNREACHABLE();
return false;
}
bool ForInStatement::IsInlineable() const {
return false;
}
bool WithEnterStatement::IsInlineable() const {
return false;
}
bool WithExitStatement::IsInlineable() const {
return false;
}
bool SwitchStatement::IsInlineable() const {
return false;
}
bool TryStatement::IsInlineable() const {
return false;
}
bool TryCatchStatement::IsInlineable() const {
return false;
}
bool TryFinallyStatement::IsInlineable() const {
return false;
}
bool CatchExtensionObject::IsInlineable() const {
return false;
}
bool DebuggerStatement::IsInlineable() const {
return false;
}
bool Throw::IsInlineable() const {
return exception()->IsInlineable();
}
bool MaterializedLiteral::IsInlineable() const {
// TODO(1322): Allow materialized literals.
return false;
}
bool FunctionLiteral::IsInlineable() const {
// TODO(1322): Allow materialized literals.
return false;
}
bool ThisFunction::IsInlineable() const {
return false;
}
bool SharedFunctionInfoLiteral::IsInlineable() const {
return false;
}
bool ValidLeftHandSideSentinel::IsInlineable() const {
UNREACHABLE();
return false;
}
bool ForStatement::IsInlineable() const {
return (init() == NULL || init()->IsInlineable())
&& (cond() == NULL || cond()->IsInlineable())
&& (next() == NULL || next()->IsInlineable())
&& body()->IsInlineable();
}
bool WhileStatement::IsInlineable() const {
return cond()->IsInlineable()
&& body()->IsInlineable();
}
bool DoWhileStatement::IsInlineable() const {
return cond()->IsInlineable()
&& body()->IsInlineable();
}
bool ContinueStatement::IsInlineable() const {
return true;
}
bool BreakStatement::IsInlineable() const {
return true;
}
bool EmptyStatement::IsInlineable() const {
return true;
}
bool Literal::IsInlineable() const {
return true;
}
bool Block::IsInlineable() const {
const int count = statements_.length();
for (int i = 0; i < count; ++i) {
if (!statements_[i]->IsInlineable()) return false;
}
return true;
}
bool ExpressionStatement::IsInlineable() const {
return expression()->IsInlineable();
}
bool IfStatement::IsInlineable() const {
return condition()->IsInlineable()
&& then_statement()->IsInlineable()
&& else_statement()->IsInlineable();
}
bool ReturnStatement::IsInlineable() const {
return expression()->IsInlineable();
}
bool Conditional::IsInlineable() const {
return condition()->IsInlineable() && then_expression()->IsInlineable() &&
else_expression()->IsInlineable();
}
bool VariableProxy::IsInlineable() const {
return var()->is_global() || var()->IsStackAllocated();
}
bool Assignment::IsInlineable() const {
return target()->IsInlineable() && value()->IsInlineable();
}
bool Property::IsInlineable() const {
return obj()->IsInlineable() && key()->IsInlineable();
}
bool Call::IsInlineable() const {
if (!expression()->IsInlineable()) return false;
const int count = arguments()->length();
for (int i = 0; i < count; ++i) {
if (!arguments()->at(i)->IsInlineable()) return false;
}
return true;
}
bool CallNew::IsInlineable() const {
if (!expression()->IsInlineable()) return false;
const int count = arguments()->length();
for (int i = 0; i < count; ++i) {
if (!arguments()->at(i)->IsInlineable()) return false;
}
return true;
}
bool CallRuntime::IsInlineable() const {
const int count = arguments()->length();
for (int i = 0; i < count; ++i) {
if (!arguments()->at(i)->IsInlineable()) return false;
}
return true;
}
bool UnaryOperation::IsInlineable() const {
return expression()->IsInlineable();
}
bool BinaryOperation::IsInlineable() const {
return left()->IsInlineable() && right()->IsInlineable();
}
bool CompareOperation::IsInlineable() const {
return left()->IsInlineable() && right()->IsInlineable();
}
bool CompareToNull::IsInlineable() const {
return expression()->IsInlineable();
}
bool CountOperation::IsInlineable() const {
return expression()->IsInlineable();
}
// ----------------------------------------------------------------------------
// Recording of type feedback
void Property::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
// Record type feedback from the oracle in the AST.
is_monomorphic_ = oracle->LoadIsMonomorphic(this);
if (key()->IsPropertyName()) {
if (oracle->LoadIsBuiltin(this, Builtins::kLoadIC_ArrayLength)) {
is_array_length_ = true;
} else if (oracle->LoadIsBuiltin(this, Builtins::kLoadIC_StringLength)) {
is_string_length_ = true;
} else if (oracle->LoadIsBuiltin(this,
Builtins::kLoadIC_FunctionPrototype)) {
is_function_prototype_ = true;
} else {
Literal* lit_key = key()->AsLiteral();
ASSERT(lit_key != NULL && lit_key->handle()->IsString());
Handle<String> name = Handle<String>::cast(lit_key->handle());
ZoneMapList* types = oracle->LoadReceiverTypes(this, name);
receiver_types_ = types;
}
} else if (oracle->LoadIsBuiltin(this, Builtins::kKeyedLoadIC_String)) {
is_string_access_ = true;
} else if (is_monomorphic_) {
monomorphic_receiver_type_ = oracle->LoadMonomorphicReceiverType(this);
if (monomorphic_receiver_type_->has_external_array_elements()) {
set_external_array_type(oracle->GetKeyedLoadExternalArrayType(this));
}
}
}
void Assignment::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
Property* prop = target()->AsProperty();
ASSERT(prop != NULL);
is_monomorphic_ = oracle->StoreIsMonomorphic(this);
if (prop->key()->IsPropertyName()) {
Literal* lit_key = prop->key()->AsLiteral();
ASSERT(lit_key != NULL && lit_key->handle()->IsString());
Handle<String> name = Handle<String>::cast(lit_key->handle());
ZoneMapList* types = oracle->StoreReceiverTypes(this, name);
receiver_types_ = types;
} else if (is_monomorphic_) {
// Record receiver type for monomorphic keyed loads.
monomorphic_receiver_type_ = oracle->StoreMonomorphicReceiverType(this);
if (monomorphic_receiver_type_->has_external_array_elements()) {
set_external_array_type(oracle->GetKeyedStoreExternalArrayType(this));
}
}
}
void CountOperation::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
is_monomorphic_ = oracle->StoreIsMonomorphic(this);
if (is_monomorphic_) {
// Record receiver type for monomorphic keyed loads.
monomorphic_receiver_type_ = oracle->StoreMonomorphicReceiverType(this);
if (monomorphic_receiver_type_->has_external_array_elements()) {
set_external_array_type(oracle->GetKeyedStoreExternalArrayType(this));
}
}
}
void CaseClause::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
TypeInfo info = oracle->SwitchType(this);
if (info.IsSmi()) {
compare_type_ = SMI_ONLY;
} else if (info.IsNonPrimitive()) {
compare_type_ = OBJECT_ONLY;
} else {
ASSERT(compare_type_ == NONE);
}
}
static bool CanCallWithoutIC(Handle<JSFunction> target, int arity) {
SharedFunctionInfo* info = target->shared();
// If the number of formal parameters of the target function does
// not match the number of arguments we're passing, we don't want to
// deal with it. Otherwise, we can call it directly.
return !target->NeedsArgumentsAdaption() ||
info->formal_parameter_count() == arity;
}
bool Call::ComputeTarget(Handle<Map> type, Handle<String> name) {
if (check_type_ == RECEIVER_MAP_CHECK) {
// For primitive checks the holder is set up to point to the
// corresponding prototype object, i.e. one step of the algorithm
// below has been already performed.
// For non-primitive checks we clear it to allow computing targets
// for polymorphic calls.
holder_ = Handle<JSObject>::null();
}
while (true) {
LookupResult lookup;
type->LookupInDescriptors(NULL, *name, &lookup);
// If the function wasn't found directly in the map, we start
// looking upwards through the prototype chain.
if (!lookup.IsFound() && type->prototype()->IsJSObject()) {
holder_ = Handle<JSObject>(JSObject::cast(type->prototype()));
type = Handle<Map>(holder()->map());
} else if (lookup.IsProperty() && lookup.type() == CONSTANT_FUNCTION) {
target_ = Handle<JSFunction>(lookup.GetConstantFunctionFromMap(*type));
return CanCallWithoutIC(target_, arguments()->length());
} else {
return false;
}
}
}
bool Call::ComputeGlobalTarget(Handle<GlobalObject> global,
LookupResult* lookup) {
target_ = Handle<JSFunction>::null();
cell_ = Handle<JSGlobalPropertyCell>::null();
ASSERT(lookup->IsProperty() &&
lookup->type() == NORMAL &&
lookup->holder() == *global);
cell_ = Handle<JSGlobalPropertyCell>(global->GetPropertyCell(lookup));
if (cell_->value()->IsJSFunction()) {
Handle<JSFunction> candidate(JSFunction::cast(cell_->value()));
// If the function is in new space we assume it's more likely to
// change and thus prefer the general IC code.
if (!HEAP->InNewSpace(*candidate) &&
CanCallWithoutIC(candidate, arguments()->length())) {
target_ = candidate;
return true;
}
}
return false;
}
void Call::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
Property* property = expression()->AsProperty();
ASSERT(property != NULL);
// Specialize for the receiver types seen at runtime.
Literal* key = property->key()->AsLiteral();
ASSERT(key != NULL && key->handle()->IsString());
Handle<String> name = Handle<String>::cast(key->handle());
receiver_types_ = oracle->CallReceiverTypes(this, name);
#ifdef DEBUG
if (FLAG_enable_slow_asserts) {
if (receiver_types_ != NULL) {
int length = receiver_types_->length();
for (int i = 0; i < length; i++) {
Handle<Map> map = receiver_types_->at(i);
ASSERT(!map.is_null() && *map != NULL);
}
}
}
#endif
is_monomorphic_ = oracle->CallIsMonomorphic(this);
check_type_ = oracle->GetCallCheckType(this);
if (is_monomorphic_) {
Handle<Map> map;
if (receiver_types_ != NULL && receiver_types_->length() > 0) {
ASSERT(check_type_ == RECEIVER_MAP_CHECK);
map = receiver_types_->at(0);
} else {
ASSERT(check_type_ != RECEIVER_MAP_CHECK);
holder_ = Handle<JSObject>(
oracle->GetPrototypeForPrimitiveCheck(check_type_));
map = Handle<Map>(holder_->map());
}
is_monomorphic_ = ComputeTarget(map, name);
}
}
void CompareOperation::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
TypeInfo info = oracle->CompareType(this);
if (info.IsSmi()) {
compare_type_ = SMI_ONLY;
} else if (info.IsNonPrimitive()) {
compare_type_ = OBJECT_ONLY;
} else {
ASSERT(compare_type_ == NONE);
}
}
// ----------------------------------------------------------------------------
// Implementation of AstVisitor
bool AstVisitor::CheckStackOverflow() {
if (stack_overflow_) return true;
StackLimitCheck check(isolate_);
if (!check.HasOverflowed()) return false;
return (stack_overflow_ = true);
}
void AstVisitor::VisitDeclarations(ZoneList<Declaration*>* declarations) {
for (int i = 0; i < declarations->length(); i++) {
Visit(declarations->at(i));
}
}
void AstVisitor::VisitStatements(ZoneList<Statement*>* statements) {
for (int i = 0; i < statements->length(); i++) {
Visit(statements->at(i));
}
}
void AstVisitor::VisitExpressions(ZoneList<Expression*>* expressions) {
for (int i = 0; i < expressions->length(); i++) {
// The variable statement visiting code may pass NULL expressions
// to this code. Maybe this should be handled by introducing an
// undefined expression or literal? Revisit this code if this
// changes
Expression* expression = expressions->at(i);
if (expression != NULL) Visit(expression);
}
}
// ----------------------------------------------------------------------------
// Regular expressions
#define MAKE_ACCEPT(Name) \
void* RegExp##Name::Accept(RegExpVisitor* visitor, void* data) { \
return visitor->Visit##Name(this, data); \
}
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ACCEPT)
#undef MAKE_ACCEPT
#define MAKE_TYPE_CASE(Name) \
RegExp##Name* RegExpTree::As##Name() { \
return NULL; \
} \
bool RegExpTree::Is##Name() { return false; }
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_TYPE_CASE)
#undef MAKE_TYPE_CASE
#define MAKE_TYPE_CASE(Name) \
RegExp##Name* RegExp##Name::As##Name() { \
return this; \
} \
bool RegExp##Name::Is##Name() { return true; }
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_TYPE_CASE)
#undef MAKE_TYPE_CASE
RegExpEmpty RegExpEmpty::kInstance;
static Interval ListCaptureRegisters(ZoneList<RegExpTree*>* children) {
Interval result = Interval::Empty();
for (int i = 0; i < children->length(); i++)
result = result.Union(children->at(i)->CaptureRegisters());
return result;
}
Interval RegExpAlternative::CaptureRegisters() {
return ListCaptureRegisters(nodes());
}
Interval RegExpDisjunction::CaptureRegisters() {
return ListCaptureRegisters(alternatives());
}
Interval RegExpLookahead::CaptureRegisters() {
return body()->CaptureRegisters();
}
Interval RegExpCapture::CaptureRegisters() {
Interval self(StartRegister(index()), EndRegister(index()));
return self.Union(body()->CaptureRegisters());
}
Interval RegExpQuantifier::CaptureRegisters() {
return body()->CaptureRegisters();
}
bool RegExpAssertion::IsAnchoredAtStart() {
return type() == RegExpAssertion::START_OF_INPUT;
}
bool RegExpAssertion::IsAnchoredAtEnd() {
return type() == RegExpAssertion::END_OF_INPUT;
}
bool RegExpAlternative::IsAnchoredAtStart() {
ZoneList<RegExpTree*>* nodes = this->nodes();
for (int i = 0; i < nodes->length(); i++) {
RegExpTree* node = nodes->at(i);
if (node->IsAnchoredAtStart()) { return true; }
if (node->max_match() > 0) { return false; }
}
return false;
}
bool RegExpAlternative::IsAnchoredAtEnd() {
ZoneList<RegExpTree*>* nodes = this->nodes();
for (int i = nodes->length() - 1; i >= 0; i--) {
RegExpTree* node = nodes->at(i);
if (node->IsAnchoredAtEnd()) { return true; }
if (node->max_match() > 0) { return false; }
}
return false;
}
bool RegExpDisjunction::IsAnchoredAtStart() {
ZoneList<RegExpTree*>* alternatives = this->alternatives();
for (int i = 0; i < alternatives->length(); i++) {
if (!alternatives->at(i)->IsAnchoredAtStart())
return false;
}
return true;
}
bool RegExpDisjunction::IsAnchoredAtEnd() {
ZoneList<RegExpTree*>* alternatives = this->alternatives();
for (int i = 0; i < alternatives->length(); i++) {
if (!alternatives->at(i)->IsAnchoredAtEnd())
return false;
}
return true;
}
bool RegExpLookahead::IsAnchoredAtStart() {
return is_positive() && body()->IsAnchoredAtStart();
}
bool RegExpCapture::IsAnchoredAtStart() {
return body()->IsAnchoredAtStart();
}
bool RegExpCapture::IsAnchoredAtEnd() {
return body()->IsAnchoredAtEnd();
}
// Convert regular expression trees to a simple sexp representation.
// This representation should be different from the input grammar
// in as many cases as possible, to make it more difficult for incorrect
// parses to look as correct ones which is likely if the input and
// output formats are alike.
class RegExpUnparser: public RegExpVisitor {
public:
RegExpUnparser();
void VisitCharacterRange(CharacterRange that);
SmartPointer<const char> ToString() { return stream_.ToCString(); }
#define MAKE_CASE(Name) virtual void* Visit##Name(RegExp##Name*, void* data);
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
#undef MAKE_CASE
private:
StringStream* stream() { return &stream_; }
HeapStringAllocator alloc_;
StringStream stream_;
};
RegExpUnparser::RegExpUnparser() : stream_(&alloc_) {
}
void* RegExpUnparser::VisitDisjunction(RegExpDisjunction* that, void* data) {
stream()->Add("(|");
for (int i = 0; i < that->alternatives()->length(); i++) {
stream()->Add(" ");
that->alternatives()->at(i)->Accept(this, data);
}
stream()->Add(")");
return NULL;
}
void* RegExpUnparser::VisitAlternative(RegExpAlternative* that, void* data) {
stream()->Add("(:");
for (int i = 0; i < that->nodes()->length(); i++) {
stream()->Add(" ");
that->nodes()->at(i)->Accept(this, data);
}
stream()->Add(")");
return NULL;
}
void RegExpUnparser::VisitCharacterRange(CharacterRange that) {
stream()->Add("%k", that.from());
if (!that.IsSingleton()) {
stream()->Add("-%k", that.to());
}
}
void* RegExpUnparser::VisitCharacterClass(RegExpCharacterClass* that,
void* data) {
if (that->is_negated())
stream()->Add("^");
stream()->Add("[");
for (int i = 0; i < that->ranges()->length(); i++) {
if (i > 0) stream()->Add(" ");
VisitCharacterRange(that->ranges()->at(i));
}
stream()->Add("]");
return NULL;
}
void* RegExpUnparser::VisitAssertion(RegExpAssertion* that, void* data) {
switch (that->type()) {
case RegExpAssertion::START_OF_INPUT:
stream()->Add("@^i");
break;
case RegExpAssertion::END_OF_INPUT:
stream()->Add("@$i");
break;
case RegExpAssertion::START_OF_LINE:
stream()->Add("@^l");
break;
case RegExpAssertion::END_OF_LINE:
stream()->Add("@$l");
break;
case RegExpAssertion::BOUNDARY:
stream()->Add("@b");
break;
case RegExpAssertion::NON_BOUNDARY:
stream()->Add("@B");
break;
}
return NULL;
}
void* RegExpUnparser::VisitAtom(RegExpAtom* that, void* data) {
stream()->Add("'");
Vector<const uc16> chardata = that->data();
for (int i = 0; i < chardata.length(); i++) {
stream()->Add("%k", chardata[i]);
}
stream()->Add("'");
return NULL;
}
void* RegExpUnparser::VisitText(RegExpText* that, void* data) {
if (that->elements()->length() == 1) {
that->elements()->at(0).data.u_atom->Accept(this, data);
} else {
stream()->Add("(!");
for (int i = 0; i < that->elements()->length(); i++) {
stream()->Add(" ");
that->elements()->at(i).data.u_atom->Accept(this, data);
}
stream()->Add(")");
}
return NULL;
}
void* RegExpUnparser::VisitQuantifier(RegExpQuantifier* that, void* data) {
stream()->Add("(# %i ", that->min());
if (that->max() == RegExpTree::kInfinity) {
stream()->Add("- ");
} else {
stream()->Add("%i ", that->max());
}
stream()->Add(that->is_greedy() ? "g " : that->is_possessive() ? "p " : "n ");
that->body()->Accept(this, data);
stream()->Add(")");
return NULL;
}
void* RegExpUnparser::VisitCapture(RegExpCapture* that, void* data) {
stream()->Add("(^ ");
that->body()->Accept(this, data);
stream()->Add(")");
return NULL;
}
void* RegExpUnparser::VisitLookahead(RegExpLookahead* that, void* data) {
stream()->Add("(-> ");
stream()->Add(that->is_positive() ? "+ " : "- ");
that->body()->Accept(this, data);
stream()->Add(")");
return NULL;
}
void* RegExpUnparser::VisitBackReference(RegExpBackReference* that,
void* data) {
stream()->Add("(<- %i)", that->index());
return NULL;
}
void* RegExpUnparser::VisitEmpty(RegExpEmpty* that, void* data) {
stream()->Put('%');
return NULL;
}
SmartPointer<const char> RegExpTree::ToString() {
RegExpUnparser unparser;
Accept(&unparser, NULL);
return unparser.ToString();
}
RegExpDisjunction::RegExpDisjunction(ZoneList<RegExpTree*>* alternatives)
: alternatives_(alternatives) {
ASSERT(alternatives->length() > 1);
RegExpTree* first_alternative = alternatives->at(0);
min_match_ = first_alternative->min_match();
max_match_ = first_alternative->max_match();
for (int i = 1; i < alternatives->length(); i++) {
RegExpTree* alternative = alternatives->at(i);
min_match_ = Min(min_match_, alternative->min_match());
max_match_ = Max(max_match_, alternative->max_match());
}
}
RegExpAlternative::RegExpAlternative(ZoneList<RegExpTree*>* nodes)
: nodes_(nodes) {
ASSERT(nodes->length() > 1);
min_match_ = 0;
max_match_ = 0;
for (int i = 0; i < nodes->length(); i++) {
RegExpTree* node = nodes->at(i);
min_match_ += node->min_match();
int node_max_match = node->max_match();
if (kInfinity - max_match_ < node_max_match) {
max_match_ = kInfinity;
} else {
max_match_ += node->max_match();
}
}
}
CaseClause::CaseClause(Expression* label,
ZoneList<Statement*>* statements,
int pos)
: label_(label),
statements_(statements),
position_(pos),
compare_type_(NONE),
compare_id_(AstNode::GetNextId()),
entry_id_(AstNode::GetNextId()) {
}
} } // namespace v8::internal
| [
"[email protected]"
] | [
[
[
1,
1145
]
]
] |
52a9615bf500fc5551ccd9cf785b16a8bb027250 | ea6b169a24f3584978f159ec7f44184f9e84ead8 | /include/reflect/string/String.h | 23f27d491fd4bf9fa571f558916b4d5b037fcbc3 | [] | no_license | sparecycles/reflect | e2051e5f91a7d72375dd7bfa2635cf1d285d8ef7 | bec1b6e6521080ad4d932ee940073d054c8bf57f | refs/heads/master | 2020-06-05T08:34:52.453196 | 2011-08-18T16:33:47 | 2011-08-18T16:33:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,155 | h | #ifndef REFLECT_STRING_RESIZABLESTRING_H_
#define REFLECT_STRING_RESIZABLESTRING_H_
#include <reflect/string/Fragment.h>
#include <reflect/string/MutableString.h>
#include <reflect/Reflector.h>
#include <reflect/config/config.h>
#include <reflect/Reflection.h>
namespace reflect { namespace string {
/// A String is the most complex string type in the suite.
///
/// Strings own their data, like ArrayString s,
/// but will never overflow since they can reallocate.
class ReflectExport(reflect) String
{
public:
typedef Fragment::size_type size_type;
static const size_type npos = size_type(Fragment::npos);
typedef char *iterator;
typedef const char *const_iterator;
/// Constructs an empty String
String();
/// Constructs a String from a pointer to NUL terminated data.
String(const char *s);
/// Constructs a String from a Fragment.
String(const Fragment &s);
/// Constructs a String from a Fragment.
String(const String &s);
/// @return a chararcter pointer to the data.
const char *data() const;
/// @return a chararcter pointer to NUL terminated data.
const char *c_str() const;
/// @return the current length of the string.
size_type length() const;
/// @return the current length of the string.
size_type size() const;
/// @return the current maximum length of the string.
size_type capacity() const;
/// releases the memory held by the string
~String();
/// prints formated text into the string, (like printf)
size_type format(const char *format, ...);
/// prints formated text into the string, (like vprintf)
size_type vformat(const char *format, va_list);
/// @return a const_iterator at the begining of the string.
const_iterator begin() const;
/// @return a const_iterator at the end of the string.
const_iterator end() const;
/// @return an iterator at the end of the string.
iterator begin();
/// @returns an iterator at the end of the string.
iterator end();
/// @see Fragment::find(char,size_type) const
size_type find(char ch, size_type pos = 0) const;
/// @see Fragment::find(const char *,size_type,size_type) const
size_type find(const char *s, size_type pos = 0, size_type len = npos) const;
/// @see Fragment::find(const Fragment &,size_type) const
size_type find(const Fragment &s, size_type pos = 0) const;
/// @see Fragment::find_first_of(char,size_type) const
size_type find_first_of(char ch, size_type pos = 0) const;
/// @see Fragment::find_first_of(const char *,size_type) const
size_type find_first_of(const Fragment &s, size_type pos = 0) const;
/// @see Fragment::rfind(char,size_type) const
size_type rfind(char ch, size_type pos = npos) const;
/// @see Fragment::rfind(const char *,size_type,size_type) const
size_type rfind(const char *s, size_type pos = npos, size_type len = npos) const;
/// @see Fragment::rfind(const Fragment &,size_type,size_type) const
size_type rfind(const Fragment &s, size_type pos = npos) const;
/// @see Fragment::find_last_of(char,size_type) const
size_type find_last_of(char ch, size_type pos = npos) const;
/// @see Fragment::find_last_of(const char *,size_type) const
size_type find_last_of(const Fragment &s, size_type pos = npos) const;
/// @see Fragment::substr(size_type,size_type) const
Fragment substr(size_type index, size_type amount = npos) const;
/// @see MutableString::replace()
void replace(size_type offset, size_type size, Fragment value = Fragment("", 0));
bool empty() const;
bool operator ==(const Fragment &other) const;
bool operator <=(const Fragment &other) const;
bool operator >=(const Fragment &other) const;
bool operator < (const Fragment &other) const;
bool operator > (const Fragment &other) const;
bool operator !=(const Fragment &other) const;
const String &operator =(const String &other);
const String &operator =(const Fragment &other);
const String &operator =(const char *other);
const String &operator +=(const Fragment &other);
const String &operator +=(const char *other);
const String &operator +=(char);
String &operator <<(const Fragment &other);
String &operator <<(const char *other);
String &operator <<(char);
operator ConstString() const;
operator Fragment() const;
operator MutableString();
void reserve(size_type size);
static String formatted(const char *format, ...);
static void Serialize(const String *in, String *out, Reflector &);
private:
void Serialize(Reflector &) const;
void Deserialize(Reflector &);
void copy(const char *s, size_type len);
/// Resizes the string to newsize if size is less than required,
/// retaining the number of characters specified by keep.
/// @param required the threshold below which resize will occur.
/// @param keep the amount of text to keep,
/// (sometimes we don't need to retain the old text after a resize.)
void resize(size_type required, size_type keep, size_type newsize);
char *mpBuffer;
size_type mLength;
size_type mMaxSize;
};
} }
DECLARE_PRIMITIVE_REFLECTION(reflect, reflect::string::String)
#endif
| [
"[email protected]"
] | [
[
[
1,
141
]
]
] |
ba337eac903136f8fac35778bb0a3de260cfff47 | 022d2957a29fe5054263a406bbdd85289cf17ee0 | /GontrolPC/GontrolPC/SettingDialog.h | 4b55627845f6d251ab780a28cf4c52780e9d5b7d | [] | no_license | amanuelg3/remote-control-with-android | aa6705da5c76311515ef6c4c972b7e64745be76d | 5e51aff7d1727608c615a0027c746592ebc4ba92 | refs/heads/master | 2016-09-03T01:07:29.047261 | 2011-06-11T16:25:32 | 2011-06-11T16:25:32 | 35,783,127 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 900 | h | #pragma once
#include "InputFilter.h"
#include "afxwin.h"
// CSettingDialog dialog
#include "LangRes.h"
class CSettingDialog : public CDialog, public CInputFilter
{
DECLARE_DYNAMIC(CSettingDialog)
public:
CSettingDialog(CWnd* pParent = NULL); // standard constructor
virtual ~CSettingDialog();
virtual void LoadConfig();
virtual void LoadConfig(IConfigMgr * cfmgr);
// Dialog Data
enum { IDD = IDD_SETTING };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
DECLARE_MESSAGE_MAP()
public:
afx_msg void OnNMCustomdrawSlidermovespeed(NMHDR *pNMHDR, LRESULT *pResult);
public:
virtual BOOL OnInitDialog();
virtual BOOL IsShown();
protected:
CLangRes * pLangRes;
BOOL m_fShown;
int m_langid;
CComboBox m_comboLanguage;
virtual void OnOK();
public:
afx_msg void OnDestroy();
private:
CString m_szLanguage;
};
| [
"wzmvictor@5d9a875e-b1a7-14b0-4603-314cddc6b85c"
] | [
[
[
1,
39
]
]
] |
43fd651bf1d81cf7db42059ee236451c2ba2950d | b05775cd4bc8b31c4180fe2ad53e72b36c622c84 | /trunk/aproxim/src/approximator_2.h | a56b160520eafac8778370747395094e8fd1d08a | [] | no_license | BackupTheBerlios/aproxim-svn | 9049098bfc63134d914e7c4fef448637f07d6f9c | eb94c9f028e1f8eb04f4556ec1fa99ebec02ff10 | refs/heads/master | 2021-01-21T02:27:41.388224 | 2007-06-04T18:16:04 | 2007-06-04T18:16:04 | 40,672,123 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,429 | h | /*
* Copyright (c) 2006, Anatoly Sova All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
//---------------------------------------------------------------------------
#ifndef Approximator_2H
#define Approximator_2H
//---------------------------------------------------------------------------
#include <boost/tuple/tuple.hpp>
#include "approximator.h"
using namespace boost;
typedef tuple<double,double,double> point_2;
class Approximator_2 : public Approximator
{
public:
static double GetA(const vector<point_2> &data);
static double GetB(const vector<point_2> &data);
static double GetB2(const vector<point_2> &data);
static double Delta(const vector<point_2> &data1, const vector<point_2> &data2);
static double Sigma(const vector<point_2> &data);
static double Correlation(const vector<point_2> &data);
protected:
static double GetParameter(const vector<point_2> &data, string operation);
Approximator_2();
};
#endif
| [
"dark_elf@6f459bc1-eb31-0410-9770-a4c51203e036"
] | [
[
[
1,
44
]
]
] |
1a665295a9268fb52930804ecf2852a7bbc8db90 | 1b75922773bf9e61f5c9c8572ffcdae73d34a158 | /src/bsControllerDefinition.cpp | 6566657e9ae1d9ed102a3a5263d73c1319dfe6bb | [] | no_license | warvair/bulletscript | a6db7ad4caa661e830373f4953e35053852008bc | 3f499c3afba07c251fa95cb012801ef820705f7f | refs/heads/master | 2021-01-10T20:46:53.665684 | 2010-07-03T18:50:43 | 2010-07-03T18:50:43 | 35,000,416 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,037 | cpp | #include <iostream>
#include "bsControllerDefinition.h"
namespace BS_NMSP
{
// --------------------------------------------------------------------------------
ControllerDefinition::ControllerDefinition(const String& name) :
ObjectDefinition(name, "Controller"),
mMaxEventLocals(0)
{
}
// --------------------------------------------------------------------------------
ControllerDefinition::EmitterVariable& ControllerDefinition::addEmitterVariable(const String& name,
const String& emitter,
const bstype* args)
{
EmitterVariable emit;
emit.name = name;
emit.emitter = emitter;
emit.x = args[Member_X];
emit.y = args[Member_Y];
#ifdef BS_Z_DIMENSION
emit.z = args[Member_Y];
#endif
emit.angle = args[Member_Angle];
mEmitterVariables.push_back(emit);
return mEmitterVariables[getNumEmitterVariables() - 1];
}
// --------------------------------------------------------------------------------
ControllerDefinition::EmitterVariable& ControllerDefinition::getEmitterVariable(int index)
{
return mEmitterVariables[index];
}
// --------------------------------------------------------------------------------
int ControllerDefinition::getEmitterVariableIndex(const String& name) const
{
for (int i = 0; i < getNumEmitterVariables(); ++i)
{
if (mEmitterVariables[i].name == name)
return i;
}
return BS_NotFound;
}
// --------------------------------------------------------------------------------
int ControllerDefinition::getNumEmitterVariables() const
{
return (int) mEmitterVariables.size();
}
// --------------------------------------------------------------------------------
ControllerDefinition::Event& ControllerDefinition::addEvent(const String& name, ParseTreeNode* node)
{
Event evt;
evt.name = name;
evt.numArguments = 0;
evt.node = node;
mEvents.push_back(evt);
return mEvents[getNumEvents() - 1];
}
// --------------------------------------------------------------------------------
ControllerDefinition::Event& ControllerDefinition::getEvent(int index)
{
return mEvents[index];
}
// --------------------------------------------------------------------------------
int ControllerDefinition::getEventIndex(const String& name) const
{
for (int i = 0; i < getNumEvents(); ++i)
{
if (mEvents[i].name == name)
return i;
}
return BS_NotFound;
}
// --------------------------------------------------------------------------------
int ControllerDefinition::getNumEvents() const
{
return (int) mEvents.size();
}
// --------------------------------------------------------------------------------
void ControllerDefinition::setMaxEventLocalVariables(int count)
{
mMaxEventLocals = count;
}
// --------------------------------------------------------------------------------
int ControllerDefinition::getMaxEventLocalVariables() const
{
return mMaxEventLocals;
}
// --------------------------------------------------------------------------------
} | [
"[email protected]@fe84ce02-70a6-11de-8b73-c1edde54a3c7"
] | [
[
[
1,
99
]
]
] |
136819e2c7e2cd9f3d541e32a8a0297bb56dec0c | 9c62af23e0a1faea5aaa8dd328ba1d82688823a5 | /dependencies/OgreNewt_153/include/OgreNewt/OgreNewt_TreeCollisionSerializer.h | f2d6da06825bda68da6c67c5c4382f894dd53f19 | [] | no_license | jacmoe/dsa-hl-svn | 55b05b6f28b0b8b216eac7b0f9eedf650d116f85 | 97798e1f54df9d5785fb206c7165cd011c611560 | refs/heads/master | 2021-04-22T12:07:43.389214 | 2009-11-27T22:01:03 | 2009-11-27T22:01:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,282 | h | /*
OgreNewt Library
Ogre implementation of Newton Game Dynamics SDK
OgreNewt basically has no license, you may use any or all of the library however you desire... I hope it can help you in any way.
by Walaber
*/
#ifndef _INCLUDE_OGRENEWT_TREECOLLISIONSERIALIZER
#define _INCLUDE_OGRENEWT_TREECOLLISIONSERIALIZER
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_World.h"
// OgreNewt namespace. all functions and classes use this namespace.
namespace OgreNewt
{
namespace CollisionPrimitives
{
class TreeCollision;
}
/*!
This class can be used to (de)serialize a TreeCollision. Pre-building a TreeCollision and serializing from a tool,
then deserializing it at runtime may be more efficient than building the TreeCollision on the fly, especially for complex objects.
*/
class _OgreNewtExport TreeCollisionSerializer : public Ogre::Serializer
{
public:
//! constructor
TreeCollisionSerializer();
//! destructor
virtual ~TreeCollisionSerializer();
/*!
Serialize the TreeCollision to a file with the given name.
*/
void exportTreeCollision(const CollisionPrimitives::TreeCollision* collision, const Ogre::String& filename);
/*!
Deserialize the TreeCollision from a DataStream.
*/
void importTreeCollision(Ogre::DataStreamPtr& stream, CollisionPrimitives::TreeCollision* pDest);
/*!
Callback function for Newton. It should never be called directly, but will be called by Newton to save the TreeCollision to a stream.
(Newton calls this function several times for each serialization, once for each chunk of its file format apparently)
*/
static void _CDECL _newtonSerializeCallback(void* serializeHandle, const void* buffer, size_t size);
/*!
Callback function for Newton. It should never be called directly, but will be called by Newton to load the TreeCollision from a stream.
(Newton calls this function several times for each deserialization, once for each chunk of its file format apparently)
*/
static void _CDECL _newtonDeserializeCallback(void* deserializeHandle, void* buffer, size_t size);
};
} // end NAMESPACE OgreNewt
#endif
// _INCLUDE_OGRENEWT_TREECOLLISIONSERIALIZER
| [
"natoka@4c79e8ff-cfd4-0310-af45-a38c79f83013",
"blakharaz@4c79e8ff-cfd4-0310-af45-a38c79f83013"
] | [
[
[
1,
13
],
[
15,
67
]
],
[
[
14,
14
]
]
] |
28da07f6f75835d1a7e1b64cf5daa9cfc9cac1e3 | 208475bcab65438eed5d8380f26eacd25eb58f70 | /QianExe/yx_QianMain.cpp | 089c00d3af6b85007e9c55acdda8075098004955 | [] | no_license | awzhang/MyWork | 83b3f0b9df5ff37330c0e976310d75593f806ec4 | 075ad5d0726c793a0c08f9158080a144e0bb5ea5 | refs/heads/master | 2021-01-18T07:57:03.219372 | 2011-07-05T02:41:55 | 2011-07-05T02:46:30 | 15,523,223 | 1 | 2 | null | null | null | null | GB18030 | C++ | false | false | 10,976 | cpp | #include "yx_QianStdAfx.h"
#undef MSG_HEAD
#define MSG_HEAD ("QianExe-Main ")
#define MAX_DEAL_BUF_SIZE 2048
int _InitAll()
{
// 创建消息队列
g_MsgID = msgget((key_t)1236, 0666 | IPC_CREAT);
if( g_MsgID == -1 )
{
perror("msgget error:");
return 1;
}
// 定时器初始化需放在最前面
g_objTimerMng.Init();
//g_objFlashPart4Mng.Init();
#if SMALL_VER == 0
g_objMonAlert.Init();
#endif
g_objQianIO.Init();
#if SMALL_VER == 0
g_objCarSta.Init();
#endif
g_objSpecCtrl.Init();
#if SMALL_VER == 0
g_objPhoto.Init();
#endif
// g_objKTDriverCtrl.Init();
// g_objKTIrdMod.Init();
#if USE_LIAONING_SANQI == 1
g_objApplication.Init();
g_objTransport.Init();
g_objNetWork.Init();
#if SMALL_VER == 0
g_objReport.Init();
#endif
g_objLNDownLoad.Init();
#if SMALL_VER == 0
g_objLNPhoto.Init();
#endif
#endif
#if USE_REALPOS == 1
g_objRealPos.Init();
#endif
#if USE_DRIVERCTRL == 1
g_objDriverCtrl.Init();
#endif
#if USE_COMBUS == 1
g_objComBus.Init();
#endif
#if USE_COMBUS == 2
g_objCom150TR.Init();
#endif
#if USE_BLK == 1
g_objBlk.Init();
#endif
#if USE_AUTORPT == 1
g_objAutoRpt.Init();
#endif
#if USE_LEDTYPE == 1
g_objLedBohai.Init();
#endif
#if USE_LEDTYPE == 2
g_objLedChuangLi.Init();
#endif
#if USE_LEDTYPE == 3
g_objKTLed.Init();
#endif
#if USE_DRVREC == 1
g_objDriveRecord.Init();
#endif
#if USE_DRVRECRPT == 1 || USE_DRVRECRPT == 2 || USE_DRVRECRPT == 3 || USE_DRVRECRPT == 4 || USE_DRVRECRPT == 11
g_objDrvRecRpt.Init();
#endif
#if USE_METERTYPE == 1
g_objMeter.Init();
#endif
#if USE_METERTYPE == 2
g_objKTMeter.Init();
#endif
#if USE_ACDENT == 1 || USE_ACDENT == 2
g_objAcdent.Init();
#endif
#if USE_OIL == 3
g_objOil.Init();
#endif
return 0;
}
void _ReleaseAll()
{
#if USE_AUTORPTSTATION == 1
g_objAuoRptStationNew.Release();
#endif
#if USE_OIL == 3
g_objOil.Release();
#endif
#if USE_ACDENT == 1 || USE_ACDENT == 2
g_objAcdent.Release();
#endif
#if USE_METERTYPE == 1
g_objMeter.Release();
#endif
#if USE_METERTYPE == 2
g_objKTMeter.Release();
#endif
#if USE_DRVRECRPT == 1 || USE_DRVRECRPT == 2 || USE_DRVRECRPT == 3 || USE_DRVRECRPT == 4 || USE_DRVRECRPT == 11
g_objDrvRecRpt.Release();
#endif
#if USE_LEDTYPE == 1
g_objLedBohai.Release();
#endif
#if USE_LEDTYPE == 2
g_objLedChuangLi.Release();
#endif
#if USE_LEDTYPE == 3
g_objKTLed.Release();
#endif
#if USE_COMBUS == 1
g_objComBus.Release();
#endif
#if USE_COMBUS == 2
g_objCom150TR.Release();
#endif
#if USE_DRVREC == 1
g_objDriveRecord.Release();
#endif
#if USE_DRIVERCTRL == 1
g_objDriverCtrl.Release();
#endif
#if USE_REALPOS == 1
g_objRealPos.Release();
#endif
// g_objKTIrdMod.Release();
// g_objKTDriverCtrl.Release();
#if USE_LIAONING_SANQI == 1
#if SMALL_VER == 0
g_objReport.Release();
#endif
g_objApplication.Release();
g_objTransport.Release();
g_objNetWork.Release();
g_objLNDownLoad.Release();
#if SMALL_VER == 0
g_objLNPhoto.Release();
#endif
#endif
g_objSpecCtrl.Release();
#if SMALL_VER == 0
g_objCarSta.Release();
#endif
g_objQianIO.Release();
g_objTimerMng.Release();
msgctl(g_MsgID, IPC_RMID, NULL);
}
void *G_RecvDataThread(void* arg)
{
char szbuf[MAX_DEAL_BUF_SIZE] = {0};
DWORD dwLen;
BYTE bytLvl;
DWORD dwPushTm;
DWORD dwSrcSymb;
QIANMSG msg;
int iResult;
while( !(iResult = DataWaitPop(DEV_QIAN)) )
{
if( g_bProgExit )
{
break;
}
while( !DataPop(szbuf, MAX_DEAL_BUF_SIZE, &dwLen, &dwSrcSymb, DEV_QIAN, &bytLvl) )
{
if( dwLen < 1 ) continue; //保险处理
DWORD dwPacketNum = 0;
switch( dwSrcSymb )
{
case DEV_SOCK:
g_objSock.AnalyseSockData(szbuf, (int)dwLen);
break;
case DEV_DIAODU:
g_objRecvComuDataMng.PushData((BYTE)LV1, dwLen, (char*)szbuf, dwPacketNum, DATASYMB_DIAODUTOQIAN);
break;
case DEV_PHONE:
g_objRecvComuDataMng.PushData((BYTE)LV1, dwLen, (char*)szbuf, dwPacketNum, DATASYMB_PHONETOQIAN);
break;
case DEV_GPS:
g_objRecvComuDataMng.PushData((BYTE)LV1, dwLen, (char*)szbuf, dwPacketNum, DATASYMB_GPSTOQIAN);
break;
case DEV_IO:
g_objRecvIODataMng.PushData((BYTE)LV1, dwLen, (char*)szbuf, dwPacketNum);
break;
case DEV_DVR:
g_objRecvDvrDataMng.PushData((BYTE)LV1, dwLen, (char*)szbuf, dwPacketNum);
break;
default:
break;
}
usleep(100000);
}
}
if(ERR_MSGSKIPBLOCK == iResult)
{
// DataWaitPop返回出错，可能以后需要添加一些清除操作
}
// 若接收线程退出，则整个程序退出
g_bProgExit = true;
msg.m_lMsgType = MSG_PROGQUIT;
msgsnd(g_MsgID, (void*)&msg, MSG_MAXLEN, 0);
}
void *G_DealSmsThread(void* arg)
{
char szbuf[ MAX_DEAL_BUF_SIZE ];
DWORD dwLen;
BYTE bytLvl;
BYTE bytSrcSymb;
DWORD dwPushTm;
char szTel[ 15 ] = { 0 };
while( !g_bProgExit )
{
usleep(100000);
while( !g_objRecvSmsDataMng.PopData(bytLvl, (DWORD)sizeof(szbuf), dwLen, (char*)szbuf, dwPushTm, &bytSrcSymb) )
{
if( dwLen < 1 )
continue;
g_objCfg.GetSelfTel( szTel, sizeof(szTel) );
g_objSms.DealSmsFrame((char*)szbuf, (int)dwLen, szTel, sizeof(szTel), bytSrcSymb == DATASYMB_RCVFROMSM);
}
}
}
void *G_DealIOThread(void* arg)
{
char szbuf[100];
DWORD dwLen;
BYTE bytLvl;
BYTE bytSrcSymb;
DWORD dwPushTm;
while( !g_bProgExit )
{
usleep(100000);
while( !g_objRecvIODataMng.PopData(bytLvl, (DWORD)sizeof(szbuf), dwLen, (char*)szbuf, dwPushTm, &bytSrcSymb) )
{
if( dwLen != 1 )
continue;
g_objQianIO.DealIOMsg(szbuf, dwLen, bytSrcSymb);
}
}
}
void *G_DealComuThread(void *arg)
{
char szbuf[ MAX_DEAL_BUF_SIZE ];
DWORD dwLen;
BYTE bytLvl;
BYTE bytSrcSymb;
DWORD dwPushTm;
while( !g_bProgExit )
{
usleep(100000);
while( !g_objRecvComuDataMng.PopData(bytLvl, (DWORD)sizeof(szbuf), dwLen, (char*)szbuf, dwPushTm, &bytSrcSymb) )
{
if( dwLen < 1 )
continue;
g_objComu.DealComuMsg(szbuf, dwLen, bytSrcSymb);
}
}
}
void *G_DealDvrThread(void *arg)
{
char szbuf[ MAX_DEAL_BUF_SIZE ];
DWORD dwLen;
char szSendBuf[ TCP_SENDSIZE ];
int iSendLen = 0;
BYTE bytLvl;
BYTE bytSrcSymb;
DWORD dwPushTm;
while( !g_bProgExit )
{
usleep(100000);
while( !g_objRecvDvrDataMng.PopData(bytLvl, (DWORD)sizeof(szbuf), dwLen, (char*)szbuf, dwPushTm, &bytSrcSymb) )
{
if( dwLen < 1 )
continue;
switch( szbuf[0] )
{
case 0x01: //DvrExe向通信前置机发送的数据
{
int iRet = g_objSms.MakeSmsFrame( szbuf+3, (int)dwLen-3, szbuf[1], szbuf[2], szSendBuf, sizeof(szSendBuf), iSendLen);
if( !iRet )
{
g_objSock.SOCKSNDSMSDATA( szSendBuf, iSendLen, LV12 );
}
}
break;
case 0x02: // 拍照完成通知
{
DWORD dwPacketNum;
#if USE_LIAONING_SANQI == 1
g_objLNPhoto.m_objDataMngShotDone.PushData(LV1, dwLen-1, szbuf+1, dwPacketNum);
#else
g_objPhoto.m_objDataMngShotDone.PushData(LV1, dwLen-1, szbuf+1, dwPacketNum);
#endif
QIANMSG msg;
msg.m_lMsgType = MSG_PHOTODONE;
msgsnd(g_MsgID, (void*)&msg, MSG_MAXLEN, 0);
}
break;
case 0x03: // 系统进入省电通知
{
g_objQianIO.SetDevSta(true, DEVSTA_SYSTEMSLEEP);
}
break;
case 0x04: // 系统退出省电通知
{
g_objQianIO.SetDevSta(false, DEVSTA_SYSTEMSLEEP);
}
break;
case 0x05: // SD卡挂载成功通知
{
#if USE_BLK == 1
g_objBlk.BlkSaveStart();
#endif
#if USE_DRVREC == 1
g_objDriveRecord.ReInit();
#endif
#if USE_AUTORPTSTATION == 1
sleep(3);
g_objAuoRptStationNew.init();
#endif
//初始化手柄存储文件（理应放在ComuExe进行，但在此处进行也可）
FILE* fp;
char path[100] = {0};
sprintf(path, "%s/HandsetData.dat", HANDLE_FILE_PATH);
fp = fopen(path, "rb");
//如果文件不存在则创建
if(fp == NULL)
{
fp = fopen(path, "wb+");
if (fp != NULL)
{
fwrite(0, 8192*2, 1, fp); //存储空间大小为11000byte=10.7K
fclose(fp);
}
}
else
{
fclose(fp);
}
}
break;
case 0x06: // SD卡卸载成功通知
{
#if USE_BLK == 1
g_objBlk.BlkSaveStop();
#endif
}
break;
#if USE_LIAONING_SANQI == 1
case 0x07: //DVR在线状态
{
g_objSock.m_bDVRTcpLoged = szbuf[1];
}
break;
#endif
default:
break;
}
}
}
}
void *G_ClrDogThread(void *arg)
{
int i = 0;
while( !g_bProgExit )
{
if( i++ % 5 == 0 )
{
DogClr( DOG_QIAN );
}
sleep(1);
}
}
int main()
{
ListPhoneInfo();
pthread_t pRecvData, pDealSms, pDealIO, pDealDiaodu, pDealDvr, pthread_ClrDog;
QIANMSG objMsg;
// 所有初始化操作均放在此函数内
_InitAll();
// 创建一个接收子线程、四个业务处理子线程、清看门狗线程
if( pthread_create(&pRecvData, NULL, G_RecvDataThread, NULL) != 0
|| pthread_create(&pDealSms, NULL, G_DealSmsThread, NULL) != 0
|| pthread_create(&pDealIO, NULL, G_DealIOThread, NULL) != 0
|| pthread_create(&pDealDiaodu, NULL, G_DealComuThread, NULL) != 0
|| pthread_create(&pDealDvr, NULL, G_DealDvrThread, NULL) != 0
|| pthread_create(&pthread_ClrDog, NULL, G_ClrDogThread, NULL) != 0
)
{
perror("create deal thread failed: ");
_ReleaseAll();
return ERR_THREAD;
}
PRTMSG(MSG_NOR, "QianExe begin to run!\n");
// 主线程
while( !g_bProgExit )
{
if( msgrcv(g_MsgID, (void*)&objMsg, MSG_MAXLEN, 0, 0) == -1)
{
PRTMSG(MSG_ERR, "QianExe msgrev failed:")
perror("");
usleep(100000);
continue;
}
switch( objMsg.m_lMsgType )
{
#if USE_DRVRECRPT == 1 || USE_DRVRECRPT == 2 || USE_DRVRECRPT == 3 || USE_DRVRECRPT == 4 || USE_DRVRECRPT == 11
case MSG_SAVRECSTA:
g_objDrvRecRpt.RecStaSav();
break;
case MSG_DRVECDTOSND:
g_objDrvRecRpt.DrvRecToSnd( (bool)objMsg.m_uszMsgBuf[0] );
break;
#endif
case MSG_PROGQUIT:
PRTMSG(MSG_NOR, "Recv quit msg, program quit!\n");
g_bProgExit = true;
break;
case MSG_TCPTOSEND:
g_objSock.SendTcpBufData();
break;
case MSG_PHOTODONE:
#if USE_LIAONING_SANQI == 1
g_objLNPhoto.DealOnePhotoEnd();
#else
g_objPhoto.DealOnePhotoEnd();
#endif
break;
default:
break;
}
usleep(100000);
}
g_bProgExit = true;
_ReleaseAll();
//QianExe退出会使系统立即复位，原因暂不明，此处让其sleep， 等待ComuExe调用reboot复位
sleep(15);
PRTMSG(MSG_NOR, "QianExe is now to quit\n");
return 1;
}
| [
"[email protected]"
] | [
[
[
1,
553
]
]
] |
dcecb11047ea91d0b2cbb9f0473177a5c1b11ab7 | 5f78f22de445cb41d1af97b2ccefe177e21443a0 | /ipedia/Src/iPediaStyles.cpp | 84f9b30835d0e307b1915fee9361d6bd55f553f4 | [] | no_license | chiro79/ipedia-palm | a0a1d06c4a59cfe33aaf90a52e6345939a02372d | 7ae435a03089caf7331290069f2c83e4fd59512e | refs/heads/master | 2020-03-09T13:58:52.658445 | 2006-03-11T09:44:52 | 2006-03-11T09:44:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,688 | cpp | #include <DefinitionStyle.hpp>
#include <Graphics.hpp>
#include <Text.hpp>
#include <Logging.hpp>
#include "iPediaStyles.hpp"
StaticAssert<COLOR_NOT_DEF_INDEX != COLOR_DEF_INDEX>;
// keep this array sorted!
static const StaticStyleEntry staticStyleTable[] =
{
//do not touch .xxx styles (keep them
{styleNameDefault, {BLACK, WHITE, stdFont, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, noUnderline}},
{styleNameHyperlink, {COLOR_UI_FORM_FRAME, COLOR_NOT_DEF, FONT_NOT_DEF, NOT_DEF, NOT_DEF, NOT_DEF, NOT_DEF, NOT_DEF, NOT_DEF, grayUnderline}},
COLOR_BOLD(styleNameHeader, COLOR_UI_FORM_FRAME),
/*
COLOR(styleNameBlack,BLACK),
COLOR(styleNameBlue,BLUE),
COLOR_BOLD(styleNameBold,COLOR_NOT_DEF),
COLOR_BOLD(styleNameBoldBlue,BLUE),
COLOR_BOLD(styleNameBoldGreen,GREEN),
COLOR_BOLD(styleNameBoldRed,RED),
COLOR(styleNameGray,GRAY),
COLOR(styleNameGreen,GREEN),
COLOR_AND_FONT(styleNameLarge, COLOR_NOT_DEF, largeFont),
COLOR_AND_FONT(styleNameLargeBlue, BLUE, largeFont),
COLOR_AND_FONT_BOLD(styleNamePageTitle, COLOR_UI_MENU_SELECTED_FILL, largeFont),
COLOR(styleNameRed,RED),
COLOR_AND_FONT(styleNameSmallGray, GRAY, smallFont),
COLOR(styleNameSmallHeader, COLOR_UI_FORM_FRAME),
COLOR_BOLD(styleNameStockPriceDown, RED),
COLOR_BOLD(styleNameStockPriceUp, GREEN),
COLOR(styleNameYellow,YELLOW)
*/
};
uint_t StyleGetStaticStyleCount()
{
return ARRAY_SIZE(staticStyleTable);
}
const char* StyleGetStaticStyleName(uint_t index)
{
assert(index < ARRAY_SIZE(staticStyleTable));
return staticStyleTable[index].name;
}
const DefinitionStyle* StyleGetStaticStyle(uint_t index)
{
assert(index < ARRAY_SIZE(staticStyleTable));
return &staticStyleTable[index].style;
}
const DefinitionStyle* StyleGetStaticStyle(const char* name, uint_t length)
{
return StyleGetStaticStyleHelper(staticStyleTable, ARRAY_SIZE(staticStyleTable), name, length);
}
void StylePrepareStaticStyles()
{
}
void StyleDisposeStaticStyles()
{
}
#ifndef NDEBUG
void test_StaticStyleTable()
{
// Validate that fields_ are sorted.
for (uint_t i = 0; i < ARRAY_SIZE(staticStyleTable); ++i)
{
if (i > 0 && staticStyleTable[i] < staticStyleTable[i-1])
{
const char_t* prevName = staticStyleTable[i-1].name;
const char_t* nextName = staticStyleTable[i].name;
assert(false);
}
}
//test |= operator on NULL style
DefinitionStyle* ptr = NULL;
DefinitionStyle s = *StyleGetStaticStyle(styleIndexDefault);
s |= *ptr;
}
#endif
| [
"andrzejc@38655da0-86da-0310-9534-e79ea18dc88d"
] | [
[
[
1,
92
]
]
] |
52c6490b16c7a3b08607e731d754c8a4b6347542 | 0f457762985248f4f6f06e29429955b3fd2c969a | /irrlicht/src/proto_dmk/main.cpp | ac1d918d03bb78c1c308eb71f596b517e60a812f | [] | no_license | tk8812/ukgtut | f19e14449c7e75a0aca89d194caedb9a6769bb2e | 3146ac405794777e779c2bbb0b735b0acd9a3f1e | refs/heads/master | 2021-01-01T16:55:07.417628 | 2010-11-15T16:02:53 | 2010-11-15T16:02:53 | 37,515,002 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 439 | cpp | #include <iostream>
#include <string>
#include <irrlicht.h>
#include "cdmkapp.h"
/*
제목 : 프로토타입 또는 데마크식 게임프레임웍
버전 : 2009. 8월 30일( v1.0 )
필수 공유 모듈
일리히트엔진 1.5.1
위치 : sdk/irrlicht
블릿엔진 2.5 rc7
위치 : sdk/bullet
로그:
2009.8.30 : v 1.0 최종수정
*/
void main()
{
static CdmkApp App;
App.Init();
App.gameloop();
} | [
"gbox3d@58f0f68e-7603-11de-abb5-1d1887d8974b"
] | [
[
[
1,
30
]
]
] |
6e8ba5c8e1caa0deaa30fb3a15e80996114a8d42 | c5534a6df16a89e0ae8f53bcd49a6417e8d44409 | /trunk/nGENE Proj/Maths.cpp | 73b99b37f1fe6a4a0064cc2e17b158ce612f58b2 | [] | no_license | svn2github/ngene | b2cddacf7ec035aa681d5b8989feab3383dac012 | 61850134a354816161859fe86c2907c8e73dc113 | refs/heads/master | 2023-09-03T12:34:18.944872 | 2011-07-27T19:26:04 | 2011-07-27T19:26:04 | 78,163,390 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,268 | cpp | /*
---------------------------------------------------------------------------
This source file is part of nGENE Tech.
Copyright (c) 2006- Wojciech Toman
This program is free software.
File: Maths.cpp
Version: 0.05
---------------------------------------------------------------------------
*/
#include "PrecompiledHeaders.h"
#include "Maths.h"
namespace nGENE
{
// Some important mathematical constants and numbers
// needs to be initialized here as they were declared static
Maths::ANGLE_UNIT Maths::s_AngleUnit = Maths::ANGLE_RADIAN;
const Real Maths::PI = 3.14159265f;
const Real Maths::PI_DOUBLE = 6.28318853f;
const Real Maths::PI_HALF = 1.570796325f;
const Real Maths::Infinity = 1e9;
const Real Maths::MinusInfinity = -Maths::Infinity;
const Real Maths::FloatEpsilon = 0.000001f;
FastFloat* Maths::s_FastFloat = new FastFloat();
bool Maths::m_bUseTables = true;
bool Maths::m_bUseSSE = false;
const Real Maths::m_kDegToRad = PI_DOUBLE / 360.0f;
const Real Maths::m_kRadToDeg = 180.0f / PI;
Maths::Maths()
{
}
//----------------------------------------------------------------------
Maths::~Maths()
{
}
//----------------------------------------------------------------------
} | [
"Riddlemaster@fdc6060e-f348-4335-9a41-9933a8eecd57"
] | [
[
[
1,
49
]
]
] |
3fb218aa3c50d7936515da0a7b736a8837299a94 | 5df145c06c45a6181d7402279aabf7ce9376e75e | /src/johnmainwindow.cpp | 7026cfc6a51e66ed8a4556cf91376961546615b7 | [] | no_license | plus7/openjohn | 89318163f42347bbac24e8272081d794449ab861 | 1ffdcc1ea3f0af43b9033b68e8eca048a229305f | refs/heads/master | 2021-03-12T22:55:57.315977 | 2009-05-15T11:30:00 | 2009-05-15T11:30:00 | 152,690 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,042 | cpp | /*
* Copyright 2009 NOSE Takafumi <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "johnmainwindow.h"
#include "ui_johnmainwindow.h"
#include "aboutdialog.h"
#include "bbsmenumgr.h"
#include "bbsmenumodel.h"
#include "bookmarks.h"
#include <qsplitter.h>
#include <qcombobox.h>
#include <QDirModel>
#include "treemodel.h"
#include <QProgressDialog>
#include "boardmodel.h"
#include "threadview.h"
#include <QMessageBox>
#include "johnapplication.h"
#include "bookmarks.h"
#include "bbsmenufetchdialog.h"
JohnMainWindow::JohnMainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::JohnMainWindowClass)
{
loadSettings();
ui->setupUi(this);
loadBBSMenu();
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
BookmarksMenu* bmmenu = new BookmarksMenu;
bmmenu->setTitle(tr("Bookmarks(&M)"));
ui->menuBar->insertMenu(ui->menuInsert_point_of_BookmarksMenu->menuAction(), bmmenu);
ui->menuInsert_point_of_BookmarksMenu->hide();
ui->menuBar->removeAction(ui->menuInsert_point_of_BookmarksMenu->menuAction());
BookmarksModel *boomarksModel = JohnApplication::bookmarksManager()->bookmarksModel();
m_bookmarksToolbar = new BookmarksToolBar(boomarksModel, this);
addToolBarBreak();
addToolBar(m_bookmarksToolbar);
ui->threadTabBar->addTab("uniu");
ui->threadTabBar->addTab("sss");
restoreWindowLayout();
}
JohnMainWindow::~JohnMainWindow()
{
saveWindowLayout();
delete ui;
}
void JohnMainWindow::loadSettings()
{
}
void JohnMainWindow::restoreWindowLayout(){
// ウィンドウの状態を初期化
ui->dockWidget_debug->setMaximumHeight(120);
QFile windowState(JohnApplication::profileDir()+"/settings/window.dat");
if(!windowState.exists()) return;
if(!windowState.open(QFile::ReadOnly)) return;
restoreState(windowState.readAll(), 1);
windowState.close();
}
void JohnMainWindow::saveWindowLayout(){
// ウィンドウの状態を保存
QFile windowState(JohnApplication::profileDir()+"/settings/window.dat");
if(!windowState.open(QFile::WriteOnly)) return;
windowState.write(saveState(1));
windowState.close();
}
void JohnMainWindow::loadLinkBar(){
}
void JohnMainWindow::loadBBSMenu(){
//bbsmenu
QFile bbsmenu(JohnApplication::profileDir()+"/bbsmenu.html");
if(!bbsmenu.exists()){
QMessageBox::information(NULL, "John",
tr("次に表示されるダイアログで「更新」を押し、２ちゃんねるから最新の板一覧を取得してください"));
BBSMenuFetchDialog dlg;
dlg.exec();
}
ui->boardTreeView->loadBBSMenu();
}
void JohnMainWindow::loadUri(const QString &uri)
{
}
void JohnMainWindow::on_action_AboutNemo_triggered()
{
AboutDialog dialog;
dialog.exec();
}
void JohnMainWindow::on_action_exit_triggered()
{
this->close();
}
void JohnMainWindow::on_action_ChangeSplitDir_triggered()
{
if(ui->splitter_central->orientation() == Qt::Horizontal) {
ui->splitter_central->setOrientation(Qt::Vertical);
}
else{
ui->splitter_central->setOrientation(Qt::Horizontal);
}
}
void JohnMainWindow::on_action_help_triggered()
{
QComboBox *cb = new QComboBox(ui->toolBar);
ui->toolBar->addWidget(cb);
}
void JohnMainWindow::on_action_update_bbsmenu_triggered()
{
// BBSMenuの更新
BBSMenuFetchDialog dlg;
dlg.exec();
ui->boardTreeView->loadBBSMenu();
}
void JohnMainWindow::on_boardTreeView_clicked(QModelIndex index)
{
BBSNode * node = (BBSNode *)(index.internalPointer());
if(node->type() == BBSNode::Board) {
ui->brdView->loadBoard(node->uri);
}
}
void JohnMainWindow::on_brdView_clicked(QModelIndex index)
{
BBSNode * node = (BBSNode *)(index.internalPointer());
if(!node) return;
if(node->type() == BBSNode::Thread) {
ui->threadView->loadThread(node->uri);
}
}
void JohnMainWindow::on_actionAboutQt_triggered()
{
QMessageBox::aboutQt(this);
}
| [
"[email protected]"
] | [
[
[
1,
172
]
]
] |
7f21966d32332e64218d57eed39ba105c9b65818 | 6630a81baef8700f48314901e2d39141334a10b7 | /1.4/Testing/Cxx/swWxGuiTesting/CppGuiTest/swModalDialogTest.cpp | 93b8e174dac63e37851d7741d35403476d007987 | [] | no_license | jralls/wxGuiTesting | a1c0bed0b0f5f541cc600a3821def561386e461e | 6b6e59e42cfe5b1ac9bca02fbc996148053c5699 | refs/heads/master | 2021-01-10T19:50:36.388929 | 2009-03-24T20:22:11 | 2009-03-26T18:51:24 | 623,722 | 1 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 2,992 | cpp | ///////////////////////////////////////////////////////////////////////////////
// Name: swWxGuiTesting/CppGuiTest/swModalDialogTest.cpp
// Author: Reinhold Füreder
// Created: 2006
// Copyright: (c) 2006 Reinhold Füreder
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "swModalDialogTest.h"
#endif
#include "swModalDialogTest.h"
#include "wx/dialog.h"
#include "wx/textctrl.h"
#include "wx/sizer.h"
#include "swWxGuiTestHelper.h"
#include "swWxGuiTestEventSimulationHelper.h"
#include "swFrameFactory.h"
#include "swMdiFrameFactory.h"
#include "swModalDialogTimer.h"
#include "swModalDialogManipulator.h"
#include "swDirDialogManipulator.h"
namespace swTst {
// Register test suite with special name in order to be identifiable as test
// which must be run after GUI part of wxWidgets library is initialised:
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ModalDialogTest, "WxGuiTest" );
void ModalDialogTest::setUp ()
{
// Nothing to do
}
void ModalDialogTest::tearDown ()
{
// Nothing to do
}
void ModalDialogTest::testModalDialog ()
{
wxDialog dialog (NULL, -1, "Title", wxDefaultPosition, wxDefaultSize,
wxDEFAULT_DIALOG_STYLE, "modalDialog");
wxTextCtrl *textCtrl = new wxTextCtrl (&dialog, -1);
wxBoxSizer *sizer = new wxBoxSizer (wxVERTICAL);
sizer->Add (textCtrl, 1, wxGROW | wxADJUST_MINSIZE, 0);
sizer->SetSizeHints (&dialog);
dialog.SetSizer (sizer);
ModalDialogTimer timer (wxID_OK);
timer.SetModalDialog (&dialog);
timer.Start (1000, true);
WxGuiTestEventSimulationHelper::SetTextCtrlValue (textCtrl, "init");
WxGuiTestHelper::FlushEventQueue ();
ModalDialogManipulator * manip = new ModalDialogManipulator (textCtrl);
timer.SetModalDialogInteractor (manip);
dialog.ShowModal ();
// Note: when the timer fires, the manip object will interact with the
// modal dialog before the timer closes dialog with specified return code.
CPPUNIT_ASSERT_MESSAGE ("Dialog was not ended correctly",
dialog.GetReturnCode () == wxID_OK);
CPPUNIT_ASSERT_MESSAGE ("Text control value was not set correctly",
textCtrl->GetValue () == "hello");
}
void ModalDialogTest::testStdModalDialog ()
{
wxDirDialog dialog (NULL);
ModalDialogTimer timer (wxID_OK);
timer.SetModalDialog (&dialog);
timer.Start (1000, true);
DirDialogManipulator * manip = new DirDialogManipulator (&dialog);
timer.SetModalDialogInteractor (manip);
if (dialog.ShowModal() == wxID_OK) {
CPPUNIT_ASSERT_MESSAGE ("Invalid directory was selected",
dialog.GetPath () == "z:\\test");
} else {
CPPUNIT_FAIL ("Dialog was not ended correctly");
}
}
} // End namespace swTst
| [
"john@64288482-8357-404e-ad65-de92a562ee98"
] | [
[
[
1,
108
]
]
] |
a8f28047a4bfd84c7b996c314aad429e4eca34b8 | 93eb4ff62a5fce345e5a16bd695b8725043a4242 | /com/BotPlatformSDK/stdafx.h | 71dafbea7ded0ef4376d7917198d259ead55bda8 | [] | no_license | adrianchia/botplatform | b8ed1e2494a96352e55da20e0a442ba9753d7582 | 4b04d1bb6d06b23b6a216d7a84331c6e378260c0 | refs/heads/master | 2020-04-05T02:40:08.665911 | 2010-07-09T08:38:53 | 2010-07-09T08:38:53 | 32,486,419 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 638 | h | #pragma once
#ifndef STRICT
#define STRICT
#endif
#include "targetver.h"
#define _ATL_APARTMENT_THREADED
#define _ATL_NO_AUTOMATIC_NAMESPACE
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS
#include "resource.h"
#include <atlbase.h>
#include <atlcom.h>
#include <atlctl.h>
#include <atlconv.h>
using namespace ATL;
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/threadpool.hpp>
#include <boost/thread.hpp>
#include <boost/unordered_map.hpp>
#include <boost/shared_ptr.hpp>
#include <json/json.h>
#include <string>
#include <vector>
#include <math.h>
| [
"[email protected]@0ded8006-25be-11df-b172-d5673a86adf5"
] | [
[
[
1,
34
]
]
] |
b8f8a645783f8acbd17215b3e494c6f2c4fdcb3d | 00b979f12f13ace4e98e75a9528033636dab021d | /Logger/include/Logger.hh | 24351724f9bd7bf2f25eaaf4026618f7537974ec | [] | no_license | BackupTheBerlios/ziahttpd-svn | 812e4278555fdd346b643534d175546bef32afd5 | 8c0b930d3f4a86f0622987776b5220564e89b7c8 | refs/heads/master | 2016-09-09T20:39:16.760554 | 2006-04-13T08:44:28 | 2006-04-13T08:44:28 | 40,819,288 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,210 | hh | //
// Logger.hh for in
//
// Made by Bigand Xavier
// Login <@epita.fr>
//
// Started on Mon Dec 26 12:44:16 2005 Bigand Xavier
// Last update Tue Dec 27 16:27:43 2005 Bigand Xavier
//
#ifndef __Logger_H__
#define __Logger_H__
#include <iostream>
#include <string>
#include <stdarg.h>
#include <stdio.h>
#include "ManageFlow.hh"
#ifdef WIN32
#define vsnprintf _vsnprintf
#endif
#define L_ALL 0
#define L_ERROR_WARNING 1
#define L_ERROR 2
#define L_NONE 3
#define LOGGER_STATE L_ALL
#define INFO 0
#define WARNING 1
#define ERROR 2
#define NB_TYPE 3
#define STR_SIZE 512
#define UNKNOWN -1
#define WRONG_TYPE 0
#define WRITE_ERROR 1
#define UNINITILIZED_FLOW 2
class Logger
{
private:
size_t _tStrSize;
bool _bError;
int _iError;
bool _bFlow[NB_TYPE];
ManageFlow *_Flow[NB_TYPE];
public:
Logger();
~Logger() {};
void Log(int iType, std::string sStr, ...)
{
if (iType >= LOGGER_STATE)
{
if (iType >= NB_TYPE || iType < 0)
{
_bError = true;
_iError = WRONG_TYPE;
return ;
}
if (_bFlow[iType])
{
va_list tParam;
char *pRes = new char[_tStrSize];
memset(pRes, 0, _tStrSize);
va_start(tParam, sStr);
vsnprintf(pRes, _tStrSize, sStr.c_str(), tParam);
_bError = _Flow[iType]->Write(pRes);
if (_bError)
_iError = WRITE_ERROR;
va_end(tParam);
delete[] pRes;
}
else
{
_bError = true;
_iError = UNINITILIZED_FLOW;
}
}
};
void SetFlow(int iType, ManageFlow &Flow)
{
if (iType >= LOGGER_STATE)
{
if (iType >= NB_TYPE || iType < 0)
{
_bError = true;
_iError = WRONG_TYPE;
return;
}
//delete _Flow[iType];
_Flow[iType] = &Flow;
_bFlow[iType] = true;
}
}
bool Error()
{
if (!_bError)
return false;
_bError = false;
return true;
};
bool SetMaxLen(size_t tLen)
{
if (tLen <= 0)
return false;
_tStrSize = tLen;
return true;
};
int GetError() {return _iError;};
size_t GetMaxLen() {return _tStrSize;};
};
#endif // __Logger_H__
| [
"ringo@754ce95b-6e01-0410-81d0-8774ba66fe44"
] | [
[
[
1,
127
]
]
] |
a51868cad386a61c861331fe4f501c0866a15f98 | f55665c5faa3d79d0d6fe91fcfeb8daa5adf84d0 | /LuaDebuger/DebugerInterface.h | 253600b396ed19d80ce84fa9c6f09ce2e73a884f | [] | no_license | lxinhcn/starworld | 79ed06ca49d4064307ae73156574932d6185dbab | 86eb0fb8bd268994454b0cfe6419ffef3fc0fc80 | refs/heads/master | 2021-01-10T07:43:51.858394 | 2010-09-15T02:38:48 | 2010-09-15T02:38:48 | 47,859,019 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,111 | h |
#ifndef _DEBUGER_INTERFACE
#define _DEBUGER_INTERFACE
#define BUFSIZE (32*1024)
typedef bool (*ProcessRetCmd)( char* lpszCommand, size_t size, size_t buffer_size );
enum run_mode { lua_run, lua_debug, lua_stop };
typedef class LuaDebugCommander LuaDebugCommander;
struct _command_buffer
{
char data[BUFSIZE];
size_t size;
_command_buffer *next;
};
typedef std::vector< std::string > Params;
extern bool PraseString( const char* lpszCommand, Params& param );
#define cmd_buffer 1
#define dsp_buffer 2
#define CHECKBUF( B, T, V ) (B?(T==dsp_buffer?( B->data[0] == '$' || B->data[0] == '#' ):( ( B->data[0] == '@' && _strnicmp( V, B->data+1, strlen(V) ) == 0 ) || ( B->data[0] == '#' && (_strnicmp( V, B->data+1, strlen( V ) ) == 0 ) ) ) ):false)
extern LuaDebugCommander* Create_Commander( const char* pipe, ProcessRetCmd fn );
extern _command_buffer* Debug_Command( LuaDebugCommander* Debuger, const char* szFmt, ... );
extern void Debug_ReleaseBuffer( LuaDebugCommander* Debuger, _command_buffer* buf );
extern void Destroy_Commander( LuaDebugCommander* Debuger );
#endif; | [
"albertclass@a94d7126-06ea-11de-b17c-0f1ef23b492c"
] | [
[
[
1,
29
]
]
] |
b8c8f2eaa15d1d13bfe94322ef207c9e9a2404f6 | 29fe525ea96253174002c81a12f945eeca9573e0 | /myPTM/TranManager.cpp | 004ff4f1b405aa5350536daa7030d6920f00be7d | [] | no_license | coolboy/myptm | c1d74a57540f8a590e13c90d1b6a1fd360cdbf76 | 222da87c0e54b6cf45442ab1f09b24b00a609afe | refs/heads/master | 2016-09-06T01:49:25.249072 | 2010-04-24T01:26:30 | 2010-04-24T01:26:30 | 32,131,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,277 | cpp | #include "StdAfx.h"
#include "TranManager.h"
#include <boost/variant.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/bind.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/foreach.hpp>
#include <boost/xpressive/xpressive.hpp>
#include <boost/xpressive/regex_actions.hpp>
using namespace std;
using namespace boost::xpressive;
TranManager::TranManager()
{
}
TranManager::TranManager(fileList files)
{
vector<vector<string>>::iterator fileIter;
vector<string>::iterator lineIter;
vector<string> CurrFile;
string CurrLine;
unsigned int CurrLinePos = 0;
//variables used to hold parsed strings
int fileIndex=0;
int fileNum = files.size();
//vector<int> FileCurrMode, FileCurrTranId;
int FileCurrMode[10], FileCurrTranId[10], FileCurrReadLine[10], FileLineNum[10];
int TranIdGlobal = 0;
string CurrFileName, CurrName;
Operation CurrOp;
if(fileNum > 10)
{
cerr << "two many files! " << "\n";
}
mark_tag op(1),opbegin(2), opabord(3), opcommit(4),
mode(5), filename(6), id(7), name(8), phone(9),delim(10);
cregex begin = (opbegin = 'B')
>> (delim= *_s)
>> (mode = (boost::xpressive::set= '0','1'));
cregex commit = (opcommit = 'C')
>> (delim= *_s)
>> (_n |eos);
cregex abord = (opabord = 'A')
>> (delim= *_s)
>> (_n |eos);
//cregex phone = +_d >> '-'>> +_d>> '-'>> +_d;
cregex fileop1 = (op = (boost::xpressive::set= 'R','W','D'))
>> (delim= *_s)
>> (filename= +(_w | '.'))
>> (delim= *_s) >> '('>> (delim= *_s)
>> (id= +_d) >>(delim= *_s) >> ','
>> (name= +_w) >>(delim= *_s) >> ','
>> (phone= +(_d | '-'))
>> (delim= *_s) >> ')';
cregex fileop2 = (op = (boost::xpressive::set= 'R','W','D'))
>> (delim= +_s)
>> (filename= +(_w | '.'))
>> (delim= +_s)
>> (id= +_d);
cregex fileop3 = (op = 'D')
>> (delim= +_s)
>> (filename= +(_w | '.'));
//cregex fileop2 = op;
// >> delim
// >> filename
// >> delim
// >> id;
cmatch what;
//initialize
for(fileIndex=0; fileIndex<fileNum; fileIndex++)
{
FileCurrMode[fileIndex] = -1;
FileCurrTranId[fileIndex] = 0;
FileCurrReadLine[fileIndex] = 0;
FileLineNum[fileIndex] = files[fileIndex].size();
cout << "number of transactions in file" << fileIndex << ": " << FileLineNum[fileIndex] <<"\n";
}
int fileProcessed, linesProcessed;
linesProcessed = 0;
while(1)
{
fileProcessed = 0;
for(fileIndex=0; fileIndex<fileNum; fileIndex++)
{
CurrFile = files[fileIndex];
if(FileCurrReadLine[fileIndex] < FileLineNum[fileIndex])
{
CurrLine = CurrFile.at(FileCurrReadLine[fileIndex]);
// mark_tag day(1), month(2), year(3), delim(4);
// this regex finds a date
if(regex_search(CurrLine.c_str(), what, begin))
{
std::cout << what[0] << '\n'; // whole match
FileCurrMode[fileIndex] = atoi(what[mode].str().c_str());
TranIdGlobal++;
FileCurrTranId[fileIndex] = TranIdGlobal;
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = BEGIN;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else if(regex_search(CurrLine.c_str(), what, commit))
{
std::cout << what[0] << '\n'; // whole match
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = COMMIT;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else if(regex_search(CurrLine.c_str(), what, abord))
{
std::cout << what[0] << '\n'; // whole match
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = ABORT;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else if(regex_search(CurrLine.c_str(), what, fileop1))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
CurrOp.m4 = atoi(what[id].str().c_str());
CurrOp.m5 = what[name].str();
CurrOp.m6 = what[phone].str();
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else if(regex_search(CurrLine.c_str(), what, fileop2))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
CurrOp.m4 = atoi(what[id].str().c_str());
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else if(regex_search(CurrLine.c_str(), what, fileop3))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
Transaction.push_back(CurrOp);
FileCurrReadLine[fileIndex]++;
linesProcessed++;
}
else
FileCurrReadLine[fileIndex]++;
}
}
// CurrLinePos++;
for(fileIndex=0; fileIndex<fileNum; fileIndex++)
{
if(FileCurrReadLine[fileIndex] == FileLineNum[fileIndex] || FileCurrReadLine[fileIndex] == 0)
fileProcessed++;
}
if(fileProcessed == fileNum)
break;
}
cout <<"total number of input operations: " << linesProcessed << "\n";
cout <<"total number of transactions: " << TranIdGlobal << "\n";
}
TranManager::TranManager(fileList files, int lines)
{
vector<vector<string>>::iterator fileIter;
vector<string>::iterator lineIter;
vector<string> CurrFile;
string CurrLine;
unsigned int CurrLinePos = 0;
//variables used to hold parsed strings
int fileIndex=0;
int lineIndex;
int fileNum = files.size();
//vector<int> FileCurrMode, FileCurrTranId;
int FileCurrMode[10], FileCurrTranId[10];
int TranIdGlobal = 0;
//vector<int> FileLineNum, FileLineReadNum;
int FileLineNum[10], FileLineReadNum[10];
//initialize the file properties(line numbers, current red line number, etc.)
for(fileIndex=0; fileIndex<fileNum; fileIndex++)
{
CurrFile = files[fileIndex];
FileLineNum[fileIndex] = CurrFile.size();
FileLineReadNum[fileIndex] = 0;
}
// OpType CurrOpType;
string CurrFileName, CurrName;
Operation CurrOp;
mark_tag op(1),opbegin(2), opabord(3), opcommit(4),
mode(5), filename(6), id(7), name(8), phone(9),delim(10);
cregex begin = (opbegin = 'B')
>> (delim= *_s)
>> (mode = (boost::xpressive::set= '0','1'));
cregex commit = (opcommit = 'C')
>> (delim= *_s)
>> (_n | eos);
cregex abord = (opabord = 'A')
>> (delim= *_s)
>> (_n | eos);
//cregex phone = +_d >> '-'>> +_d>> '-'>> +_d;
cregex fileop1 = (op = (boost::xpressive::set= 'R','W','D'))
>> (delim= *_s)
>> (filename= +(_w | '.'))
>> (delim= *_s) >> '('>> (delim= *_s)
>> (id= +_d) >>(delim= *_s) >> ','
>> (name= +_w) >>(delim= *_s) >> ','
>> (phone= +(_d | '-'))
>> (delim= *_s) >> ')';
cregex fileop2 = (op = (boost::xpressive::set= 'R','W','D'))
>> (delim= +_s)
>> (filename= +(_w | '.'))
>> (delim= +_s)
>> (id= +_d);
cregex fileop3 = (op = 'D')
>> (delim= +_s)
>> (filename= +(_w | '.'));
/*
cregex date = (month = repeat<1>(_d)) // find the month ...
>> (delim= (set= '/','-')) // followed by a delimiter ...
>> (day= repeat<1,2>(_d)) >> delim // and a day followed by the same delimiter ...
>> (year= repeat<1,2>(_d >> _d)); // and the year.
*/
cmatch what;
int fileProcessed;
int oldLine;
while(1)
{
fileProcessed = 0;
for(int i=0; i<fileNum; i++)
{
if(FileLineReadNum[i] == FileLineNum[i])
fileProcessed++;
}
if(fileProcessed == fileNum)
break;
while(1)
{
fileIndex = rand() % fileNum;
cout << "reading file: " << fileIndex <<"\n";
if(FileLineReadNum[fileIndex] < FileLineNum[fileIndex])
break;
}
CurrFile = files[fileIndex];
oldLine = FileLineReadNum[fileIndex];
FileLineReadNum[fileIndex] += lines;
if(FileLineReadNum[fileIndex] >= FileLineNum[fileIndex])
FileLineReadNum[fileIndex] = FileLineNum[fileIndex];
for(lineIndex=oldLine; lineIndex < FileLineReadNum[fileIndex]; lineIndex++)
{
CurrLine = CurrFile.at(lineIndex);
// mark_tag day(1), month(2), year(3), delim(4);
// this regex finds a date
if(regex_search(CurrLine.c_str(), what, begin))
{
std::cout << what[0] << '\n'; // whole match
FileCurrMode[fileIndex] = atoi(what[mode].str().c_str());
TranIdGlobal++;
FileCurrTranId[fileIndex] = TranIdGlobal;
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = BEGIN;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
}
else if(regex_search(CurrLine.c_str(), what, commit))
{
std::cout << what[0] << '\n'; // whole match
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = COMMIT;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
}
else if(regex_search(CurrLine.c_str(), what, abord))
{
std::cout << what[0] << '\n'; // whole match
CurrOp.m0 = FileCurrTranId[fileIndex];
CurrOp.m1 = ABORT;
CurrOp.m2 = FileCurrMode[fileIndex];
Transaction.push_back(CurrOp);
}
else if(regex_search(CurrLine.c_str(), what, fileop1))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
CurrOp.m4 = atoi(what[id].str().c_str());
CurrOp.m5 = what[name].str();
CurrOp.m6 = what[phone].str();
Transaction.push_back(CurrOp);
}
else if(regex_search(CurrLine.c_str(), what, fileop2))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
CurrOp.m4 = atoi(what[id].str().c_str());
Transaction.push_back(CurrOp);
}
else if(regex_search(CurrLine.c_str(), what, fileop3))
{
std::cout << what[0] << '\n'; // whole match
//operation: TRAN_ID, OP_TYPE, MODE, FILE_NAME, RECORD_ID, NAME, PHONE
CurrOp.m0 = FileCurrTranId[fileIndex];
if(what[op].compare("R") == 0)
CurrOp.m1 = READ;
else if(what[op].compare("W") == 0)
CurrOp.m1 = WRITE;
else if(what[op].compare("D") == 0)
CurrOp.m1 = DEL;
CurrOp.m2 = FileCurrMode[fileIndex];
CurrOp.m3 = what[filename].str();
Transaction.push_back(CurrOp);
}
}
}
}
std::vector<TranManager::Operation> TranManager::getTrans(void)
{
return Transaction;
}
TranManager::~TranManager(void)
{
}
| [
"yong1222@2f7a96df-5cd0-918d-fbe9-3cda5cb4a5af",
"coolcute@2f7a96df-5cd0-918d-fbe9-3cda5cb4a5af"
] | [
[
[
1,
2
],
[
11,
13
],
[
15,
154
],
[
156,
410
],
[
412,
504
]
],
[
[
3,
10
],
[
14,
14
],
[
155,
155
],
[
411,
411
]
]
] |
b94133ec65fbf0c983137894e8494bac9524b3af | 8a816dc2da5158e8d4f2081e6086575346869a16 | /RenderCSM/RenderCSMMFC/Camera.h | 6231203da7b0a0e8076e60f30021187ab41425ff | [] | no_license | yyzreal/3ds-max-exporter-plugin | ca43f9193afd471581075528b27d8a600fd2b7fa | 249f24c29dcfd6dd072c707f7642cf56cba06ef0 | refs/heads/master | 2020-04-10T14:50:13.717379 | 2011-06-12T15:10:54 | 2011-06-12T15:10:54 | 50,292,994 | 0 | 1 | null | 2016-01-24T15:07:28 | 2016-01-24T15:07:28 | null | GB18030 | C++ | false | false | 2,140 | h | #ifndef __CAMERA_H__
#define __CAMERA_H__
class Camera
{
public:
/*! \brief 默认构造函数 */
Camera( const D3DXVECTOR3 tracePos, const float distance, const float minDis, const float maxDis );
/*! \brief 析构函数 */
~Camera();
/*! \brief 重置摄像机 */
void Reset();
/*! \brief 重置摄像机视图矩阵 */
D3DXMATRIX UpdateViewMatrix();
/*! \brief 计算摄像机的预测位置 */
D3DXVECTOR3 CalculatePossibleCamPosition();
//set
void SetTracePosition( const D3DXVECTOR3 pos ) { m_tracePos = pos; }
void SetPossibleCamPosition( const D3DXVECTOR3 possibleCamPosition ) { m_possibleCameraPos = possibleCamPosition; }
void IncreaseTracePosition( const D3DXVECTOR3 posInc ) { m_tracePos += posInc; }
void SetDistance( float distance ) { m_distance = distance; }
void SetMinMaxDistance( float minDis, float maxDis ) { m_fMinDis = minDis; m_fMaxDis = maxDis; }
void SetHArc( const float arc ) { m_HArc = arc; }
void SetVArc( const float arc ) { m_VArc = arc; }
/* \brief 增加水平角度 */
void IncreaseHArc( const float arcInc );
/* \brief 增加垂直角度 */
void IncreaseVArc( const float arcInc );
/*! \brief 增加跟踪距离 */
void IncreaseDistance( float distanceInc );
//get
D3DXVECTOR3 GetTracePosition() const { return m_tracePos; }
D3DXVECTOR3 GetCamPosition() const { return m_cameraPos; }
/*! \brief 获得摄像机方向 */
D3DXVECTOR3 GetDirection();
D3DXVECTOR3 GetPossibleCamPosition() { return m_possibleCameraPos; }
float GetHArc() { return m_HArc; }
float GetVArc() { return m_VArc; }
D3DXMATRIX GetViewMatrix() { return m_matView; }
private:
D3DXVECTOR3 m_cameraPos; //!< 摄像机位置
D3DXVECTOR3 m_possibleCameraPos; //!< 预测的摄像机位置
D3DXVECTOR3 m_tracePos; //!< 跟踪点
float m_distance; //!< 距离跟踪点的距离
float m_HArc; //!< 水平旋转的角度
float m_VArc; //!< 垂直旋转的角度
D3DXMATRIX m_matView; //!< 摄像机视图矩阵
float m_fMaxDis; //!< 最大距离
float m_fMinDis; //!< 最短距离
};
#endif | [
"[email protected]@4008efc8-90d6-34c1-d252-cb7169c873e6"
] | [
[
[
1,
65
]
]
] |
cf80f7c86b31dc78bb19a7831eb9e93c29680c36 | 282057a05d0cbf9a0fe87457229f966a2ecd3550 | /EIBStdLib/include/Socket.h | 134593565d94116560b6b21ce91c44d07b3bfa55 | [] | no_license | radtek/eibsuite | 0d1b1c826f16fc7ccfd74d5e82a6f6bf18892dcd | 4504fcf4fa8c7df529177b3460d469b5770abf7a | refs/heads/master | 2021-05-29T08:34:08.764000 | 2011-12-06T20:42:06 | 2011-12-06T20:42:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,121 | h | /*
* C++ sockets on Unix and Windows
* Copyright (C) 2002
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PRACTICALSOCKET_INCLUDED__
#define __PRACTICALSOCKET_INCLUDED__
#include "EibStdLib.h"
#include "CString.h"
#include "Globals.h"
using namespace std;
/**
* Signals a problem with the execution of a socket call.
*/
class EIB_STD_EXPORT SocketException : public exception
{
public:
/**
* Construct a SocketException with a explanatory message.
* @param message explanatory message
* @param inclSysMsg true if system message (from strerror(errno))
* should be postfixed to the user provided message
*/
SocketException(const CString &message, bool inclSysMsg = false) throw();
/**
* Provided just to guarantee that no exceptions are thrown.
*/
virtual ~SocketException() throw();
/**
* Get the exception message
* @return exception message
*/
const char *what() const throw();
/**
* Get the exception error code
* @return exception error code
*/
int GetErrorCode() const throw();
private:
CString userMessage; // Exception message
int _error_code;
};
/**
* Base class representing basic communication endpoint
*/
class EIB_STD_EXPORT Socket {
public:
/**
* Close and deallocate this socket
*/
~Socket();
/**
* Get the local address
* @return local address of socket
* @exception SocketException thrown if fetch fails
*/
//CString GetLocalAddress() throw(SocketException);
void Close();
CString GetLocalAddress();
#ifdef WIN32
static CString LocalAddress(int interface_index = 0) throw (SocketException);
#else
static CString LocalAddress(const CString& interface_name = EMPTY_STRING) throw (SocketException);
#endif
/**
* Get the local port
* @return local port of socket
* @exception SocketException thrown if fetch fails
*/
int GetLocalPort() throw(SocketException);
/**
* Set the local port to the specified port and the local address
* to any interface
* @param localPort local port
* @exception SocketException thrown if setting local port fails
*/
void SetLocalPort(int localPort) throw(SocketException);
/**
* Set the local port to the specified port and the local address
* to the specified address. If you omit the port, a random port
* will be selected.
* @param localAddress local address
* @param localPort local port
* @exception SocketException thrown if setting local port or address fails
*/
void SetLocalAddressAndPort(const CString &localAddress,int localPort = 0) throw(SocketException);
/**
* If WinSock, unload the WinSock DLLs; otherwise do nothing. We ignore
* this in our sample client code but include it in the library for
* completeness. If you are running on Windows and you are concerned
* about DLL resource consumption, call this after you are done with all
* Socket instances. If you execute this on Windows while some instance of
* Socket exists, you are toast. For portability of client code, this is
* an empty function on non-Windows platforms so you can always include it.
* @exception SocketException thrown WinSock clean up fails
*/
static void CleanUp() throw(SocketException);
/**
* Resolve the specified service for the specified protocol to the
* corresponding port number in host byte order
* @param service service to resolve (e.g., "http")
* @param protocol protocol of service to resolve. Default is "tcp".
*/
static unsigned short ResolveService(const CString &service,
const CString &protocol = "tcp");
void SetNonBlocking() throw(SocketException);
void GetError(CString& error_str);
private:
Socket(const Socket &sock) { sockDesc = sock.sockDesc; };
Socket& operator=(const Socket &sock);
protected:
int sockDesc; // Socket descriptor
Socket(int type, int protocol) throw(SocketException);
Socket(int sockDesc);
};
/**
* Socket which is able to connect, send, and receive
*/
class EIB_STD_EXPORT CommunicatingSocket : public Socket {
public:
/**
* Establish a socket connection with the given foreign
* address and port
* @param foreignAddress foreign address (IP address or name)
* @param foreignPort foreign port
* @exception SocketException thrown if unable to establish connection
*/
void Connect(const CString &foreignAddress, unsigned short foreignPort)
throw(SocketException);
/**
* Write the given buffer to this socket. Call connect() before
* calling send()
* @param buffer buffer to be written
* @param bufferLen number of bytes from buffer to be written
* @exception SocketException thrown if unable to send data
*/
void Send(const void *buffer, int bufferLen) throw(SocketException);
/**
* Read into the given buffer up to bufferLen bytes data from this
* socket. Call connect() before calling recv()
* @param buffer buffer to receive the data
* @param bufferLen maximum number of bytes to read into buffer
* @return number of bytes read, 0 for EOF, and -1 for error
* @exception SocketException thrown if unable to receive data
*/
int Recv(void *buffer, int bufferLen) throw(SocketException);
/**
* Get the foreign address. Call connect() before calling recv()
* @return foreign address
* @exception SocketException thrown if unable to fetch foreign address
*/
CString GetForeignAddress() throw(SocketException);
/**
* Get the foreign port. Call connect() before calling recv()
* @return foreign port
* @exception SocketException thrown if unable to fetch foreign port
*/
unsigned short GetForeignPort() throw(SocketException);
protected:
CommunicatingSocket(int type, int protocol) throw(SocketException);
CommunicatingSocket(int newConnSD);
};
/**
* TCP socket for communication with other TCP sockets
*/
class EIB_STD_EXPORT TCPSocket : public CommunicatingSocket {
public:
/**
* Construct a TCP socket with no connection
* @exception SocketException thrown if unable to create TCP socket
*/
TCPSocket() throw(SocketException);
/**
* Construct a TCP socket with a connection to the given foreign address
* and port
* @param foreignAddress foreign address (IP address or name)
* @param foreignPort foreign port
* @exception SocketException thrown if unable to create TCP socket
*/
TCPSocket(const CString &foreignAddress, unsigned short foreignPort)
throw(SocketException);
int Recv(void *buffer, int bufferLen,int timeout) throw(SocketException);
private:
// Access for TCPServerSocket::accept() connection creation
friend class TCPServerSocket;
TCPSocket(int newConnSD);
};
/**
* TCP socket class for servers
*/
class EIB_STD_EXPORT TCPServerSocket : public Socket {
public:
/**
* Construct a TCP socket for use with a server, accepting connections
* on the specified port on any interface
* @param localPort local port of server socket, a value of zero will
* give a system-assigned unused port
* @param queueLen maximum queue length for outstanding
* connection requests (default 5)
* @exception SocketException thrown if unable to create TCP server socket
*/
TCPServerSocket(int localPort, int queueLen = 5)
throw(SocketException);
/**
* Construct a TCP socket for use with a server, accepting connections
* on the specified port on the interface specified by the given address
* @param localAddress local interface (address) of server socket
* @param localPort local port of server socket
* @param queueLen maximum queue length for outstanding
* connection requests (default 5)
* @exception SocketException thrown if unable to create TCP server socket
*/
TCPServerSocket(const CString &localAddress, int localPort,
int queueLen = 5) throw(SocketException);
/**
* Blocks until a new connection is established on this socket or error
* @return new connection socket
* @exception SocketException thrown if attempt to accept a new connection fails
*/
TCPSocket *Accept(unsigned int time_out = INFINITE) throw(SocketException);
private:
void SetListen(int queueLen) throw(SocketException);
};
/**
* UDP socket class
*/
class EIB_STD_EXPORT UDPSocket : public CommunicatingSocket {
public:
/**
* Construct a UDP socket
* @exception SocketException thrown if unable to create UDP socket
*/
UDPSocket() throw(SocketException);
/**
* Construct a UDP socket with the given local port
* @param localPort local port
* @exception SocketException thrown if unable to create UDP socket
*/
UDPSocket(unsigned short localPort) throw(SocketException);
/**
* Construct a UDP socket with the given local port and address
* @param localAddress local address
* @param localPort local port
* @exception SocketException thrown if unable to create UDP socket
*/
UDPSocket(const CString &localAddress, unsigned short localPort)
throw(SocketException);
/**
* Unset foreign address and port
* @return true if disassociation is successful
* @exception SocketException thrown if unable to disconnect UDP socket
*/
void Disconnect() throw(SocketException);
/**
* Send the given buffer as a UDP datagram to the
* specified address/port
* @param buffer buffer to be written
* @param bufferLen number of bytes to write
* @param foreignAddress address (IP address or name) to send to
* @param foreignPort port number to send to
* @return true if send is successful
* @exception SocketException thrown if unable to send datagram
*/
void SendTo(const void *buffer, int bufferLen, const CString &foreignAddress,
int foreignPort) throw(SocketException);
/**
* Send the given buffer as a UDP datagram to the
* specified address/port
* @param buffer buffer to be written
* @param bufferLen number of bytes to write
* @param foreignAddress address (IP address or name) to send to
* @param foreignPort port number to send to
* @param time_out max time to wait for socket to send data
* @return true if send is successful
* @exception SocketException thrown if unable to send datagram
*/
void SendTo(const void *buffer, int bufferLen,
const CString &foreignAddress, int foreignPort,int time_out);
/**
* Read read up to bufferLen bytes data from this socket. The given buffer
* is where the data will be placed
* @param buffer buffer to receive data
* @param bufferLen maximum number of bytes to receive
* @param sourceAddress address of datagram source
* @param sourcePort port of data source
* @return number of bytes received and -1 for error
* @exception SocketException thrown if unable to receive datagram
*/
int RecvFrom(void *buffer, int bufferLen, CString &sourceAddress,
int &sourcePort) throw(SocketException);
/**
* Read read up to bufferLen bytes data from this socket. The given buffer
* is where the data will be placed
* @param buffer buffer to receive data
* @param bufferLen maximum number of bytes to receive
* @param sourceAddress address of datagram source
* @param sourcePort port of data source
* @param time_out max time to wait for socket to receive data
* @return number of bytes received and -1 for error
* @exception SocketException thrown if unable to receive datagram
*/
int RecvFrom(void *buffer, int bufferLen, CString &sourceAddress,int &sourcePort, int time_out) throw(SocketException);
/**
* Set the multicast TTL
* @param multicastTTL multicast TTL
* @exception SocketException thrown if unable to set TTL
*/
void SetMulticastTTL(unsigned char multicastTTL) throw(SocketException);
/**
* Join the specified multicast group
* @param multicastGroup multicast group address to join
* @exception SocketException thrown if unable to join group
*/
void JoinGroup(const CString& local_address,const CString& multicastGroup) throw(SocketException);
/**
* Leave the specified multicast group
* @param multicastGroup multicast group address to leave
* @exception SocketException thrown if unable to leave group
*/
void LeaveGroup(const CString& multicastGroup) throw(SocketException);
/**
* Enable/Disable multicast packets on loopback interface
* @param val flag to Enable(true)/Disable(false)
* @exception SocketException thrown if unable to set the socket option
*/
void SetMulticastLoopBack(bool val) throw(SocketException);
private:
void SetBroadcast();
};
//#ifdef WIN32
//#pragma warning( default : 4290 )
//#endif
#endif
| [
"[email protected]"
] | [
[
[
1,
397
]
]
] |
8e0ed1d8765cfc40454807a9601c28f9ed19ce5c | 854ee643a4e4d0b7a202fce237ee76b6930315ec | /arcemu_svn/src/sun/src/QuestScripts/SilvermoonCity.cpp | 40ecb28a31697e44f110746ea3c87c0523a87f39 | [] | no_license | miklasiak/projekt | df37fa82cf2d4a91c2073f41609bec8b2f23cf66 | 064402da950555bf88609e98b7256d4dc0af248a | refs/heads/master | 2021-01-01T19:29:49.778109 | 2008-11-10T17:14:14 | 2008-11-10T17:14:14 | 34,016,391 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,970 | cpp | /*
* WEmu Scripts for WEmu MMORPG Server
* Copyright (C) 2008 WEmu Team
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "StdAfx.h"
#include "Setup.h"
#include "EAS/EasyFunctions.h"
class ThePathoftheAdept : public GameObjectAIScript
{
public:
ThePathoftheAdept(GameObject* goinstance) : GameObjectAIScript(goinstance) {}
static GameObjectAIScript *Create(GameObject * GO) { return new ThePathoftheAdept(GO); }
void OnActivate(Player * pPlayer)
{
if(!pPlayer)
return;
QuestLogEntry *qle = pPlayer->GetQuestLogForEntry(9692);
if(qle == NULL)
return;
Creature *zelemar = sEAS.SpawnCreature(pPlayer, 17830, pPlayer->GetPositionX()+5, pPlayer->GetPositionY()+5, pPlayer->GetPositionZ(), pPlayer->GetOrientation(), 0);
zelemar->Despawn(6*60*1000, 0);
}
};
class PathoftheAdept : public GossipScript
{
public:
void GossipHello(Object* pObject, Player* plr, bool AutoSend)
{
if(!plr)
return;
GossipMenu *Menu;
Creature *lord = (Creature*)(pObject);
if (lord == NULL)
return;
objmgr.CreateGossipMenuForPlayer(&Menu, pObject->GetGUID(), 1, plr);
if(plr->GetQuestLogForEntry(9692))
Menu->AddItem( 0, "Take Insignia", 1);
if(AutoSend)
Menu->SendTo(plr);
}
void GossipSelectOption(Object* pObject, Player* plr, uint32 Id, uint32 IntId, const char * EnteredCode)
{
if(!plr)
return;
Creature *lord = (Creature*)(pObject);
if (lord == NULL)
return;
switch (IntId)
{
case 0:
GossipHello(pObject, plr, true);
break;
case 1:
{
sEAS.AddItem(24226, plr);
return;
}break;
}
}
void Destroy()
{
delete this;
}
};
class LordDawnstar : public CreatureAIScript
{
public:
ADD_CREATURE_FACTORY_FUNCTION(LordDawnstar);
LordDawnstar(Creature* pCreature) : CreatureAIScript(pCreature) {}
void OnLoad()
{
_unit->SetUInt32Value(UNIT_NPC_FLAGS, 1);
_unit->SetStandState(7);
_unit->setDeathState(CORPSE);
_unit->GetAIInterface()->m_canMove = false;
}
};
void SetupSilvermoonCity(ScriptMgr * mgr)
{
mgr->register_gameobject_script(182024, &ThePathoftheAdept::Create);
GossipScript *LordGossip = (GossipScript*) new PathoftheAdept();
mgr->register_gossip_script(17832, LordGossip);
mgr->register_creature_script(17832, &LordDawnstar::Create);
}
| [
"[email protected]@3074cc92-8d2b-11dd-8ab4-67102e0efeef"
] | [
[
[
1,
119
]
]
] |
f13b2ee99958e68a0d60382e0f3c01141d019ea7 | 10c14a95421b63a71c7c99adf73e305608c391bf | /gui/painting/qcolor_p.cpp | 5b2a8a155d6944d0366f8cc9f5dd24480ec63b6b | [] | no_license | eaglezzb/wtlcontrols | 73fccea541c6ef1f6db5600f5f7349f5c5236daa | 61b7fce28df1efe4a1d90c0678ec863b1fd7c81c | refs/heads/master | 2021-01-22T13:47:19.456110 | 2009-05-19T10:58:42 | 2009-05-19T10:58:42 | 33,811,815 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,471 | cpp | /****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information ([email protected])
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/
// #include "qglobal.h"
#include "core/qglobal.h"
#include <string.h>
#if defined(Q_CC_BOR)
// needed for qsort() because of a std namespace problem on Borland
#include "qplatformdefs.h"
#endif
#include "qrgb.h"
// #include "qstringlist.h"
#if defined(Q_OS_WINCE)
#include "qguifunctions_wince.h"
#endif
QT_BEGIN_NAMESPACE
static inline int h2i(char hex)
{
if (hex >= '0' && hex <= '9')
return hex - '0';
if (hex >= 'a' && hex <= 'f')
return hex - 'a' + 10;
if (hex >= 'A' && hex <= 'F')
return hex - 'A' + 10;
return -1;
}
static inline int hex2int(const char *s)
{
return (h2i(s[0]) << 4) | h2i(s[1]);
}
static inline int hex2int(char s)
{
int h = h2i(s);
return (h << 4) | h;
}
bool qt_get_hex_rgb(const char *name, QRgb *rgb)
{
if(name[0] != '#')
return false;
name++;
int len = strlen(name);
int r, g, b;
if (len == 12) {
r = hex2int(name);
g = hex2int(name + 4);
b = hex2int(name + 8);
} else if (len == 9) {
r = hex2int(name);
g = hex2int(name + 3);
b = hex2int(name + 6);
} else if (len == 6) {
r = hex2int(name);
g = hex2int(name + 2);
b = hex2int(name + 4);
} else if (len == 3) {
r = hex2int(name[0]);
g = hex2int(name[1]);
b = hex2int(name[2]);
} else {
r = g = b = -1;
}
if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255) {
*rgb = 0;
return false;
}
*rgb = qRgb(r, g ,b);
return true;
}
// bool qt_get_hex_rgb(const QChar *str, int len, QRgb *rgb)
// {
// if (len > 13)
// return false;
// char tmp[16];
// for(int i = 0; i < len; ++i)
// tmp[i] = str[i].toLatin1();
// tmp[len] = 0;
// return qt_get_hex_rgb(tmp, rgb);
// }
//
#ifndef QT_NO_COLORNAMES
/*
CSS color names = SVG 1.0 color names + transparent (rgba(0,0,0,0))
*/
#ifdef rgb
# undef rgb
#endif
#define rgb(r,g,b) (0xff000000 | (r << 16) | (g << 8) | b)
static const struct RGBData {
const char *name;
uint value;
} rgbTbl[] = {
{ "aliceblue", rgb(240, 248, 255) },
{ "antiquewhite", rgb(250, 235, 215) },
{ "aqua", rgb( 0, 255, 255) },
{ "aquamarine", rgb(127, 255, 212) },
{ "azure", rgb(240, 255, 255) },
{ "beige", rgb(245, 245, 220) },
{ "bisque", rgb(255, 228, 196) },
{ "black", rgb( 0, 0, 0) },
{ "blanchedalmond", rgb(255, 235, 205) },
{ "blue", rgb( 0, 0, 255) },
{ "blueviolet", rgb(138, 43, 226) },
{ "brown", rgb(165, 42, 42) },
{ "burlywood", rgb(222, 184, 135) },
{ "cadetblue", rgb( 95, 158, 160) },
{ "chartreuse", rgb(127, 255, 0) },
{ "chocolate", rgb(210, 105, 30) },
{ "coral", rgb(255, 127, 80) },
{ "cornflowerblue", rgb(100, 149, 237) },
{ "cornsilk", rgb(255, 248, 220) },
{ "crimson", rgb(220, 20, 60) },
{ "cyan", rgb( 0, 255, 255) },
{ "darkblue", rgb( 0, 0, 139) },
{ "darkcyan", rgb( 0, 139, 139) },
{ "darkgoldenrod", rgb(184, 134, 11) },
{ "darkgray", rgb(169, 169, 169) },
{ "darkgreen", rgb( 0, 100, 0) },
{ "darkgrey", rgb(169, 169, 169) },
{ "darkkhaki", rgb(189, 183, 107) },
{ "darkmagenta", rgb(139, 0, 139) },
{ "darkolivegreen", rgb( 85, 107, 47) },
{ "darkorange", rgb(255, 140, 0) },
{ "darkorchid", rgb(153, 50, 204) },
{ "darkred", rgb(139, 0, 0) },
{ "darksalmon", rgb(233, 150, 122) },
{ "darkseagreen", rgb(143, 188, 143) },
{ "darkslateblue", rgb( 72, 61, 139) },
{ "darkslategray", rgb( 47, 79, 79) },
{ "darkslategrey", rgb( 47, 79, 79) },
{ "darkturquoise", rgb( 0, 206, 209) },
{ "darkviolet", rgb(148, 0, 211) },
{ "deeppink", rgb(255, 20, 147) },
{ "deepskyblue", rgb( 0, 191, 255) },
{ "dimgray", rgb(105, 105, 105) },
{ "dimgrey", rgb(105, 105, 105) },
{ "dodgerblue", rgb( 30, 144, 255) },
{ "firebrick", rgb(178, 34, 34) },
{ "floralwhite", rgb(255, 250, 240) },
{ "forestgreen", rgb( 34, 139, 34) },
{ "fuchsia", rgb(255, 0, 255) },
{ "gainsboro", rgb(220, 220, 220) },
{ "ghostwhite", rgb(248, 248, 255) },
{ "gold", rgb(255, 215, 0) },
{ "goldenrod", rgb(218, 165, 32) },
{ "gray", rgb(128, 128, 128) },
{ "green", rgb( 0, 128, 0) },
{ "greenyellow", rgb(173, 255, 47) },
{ "grey", rgb(128, 128, 128) },
{ "honeydew", rgb(240, 255, 240) },
{ "hotpink", rgb(255, 105, 180) },
{ "indianred", rgb(205, 92, 92) },
{ "indigo", rgb( 75, 0, 130) },
{ "ivory", rgb(255, 255, 240) },
{ "khaki", rgb(240, 230, 140) },
{ "lavender", rgb(230, 230, 250) },
{ "lavenderblush", rgb(255, 240, 245) },
{ "lawngreen", rgb(124, 252, 0) },
{ "lemonchiffon", rgb(255, 250, 205) },
{ "lightblue", rgb(173, 216, 230) },
{ "lightcoral", rgb(240, 128, 128) },
{ "lightcyan", rgb(224, 255, 255) },
{ "lightgoldenrodyellow", rgb(250, 250, 210) },
{ "lightgray", rgb(211, 211, 211) },
{ "lightgreen", rgb(144, 238, 144) },
{ "lightgrey", rgb(211, 211, 211) },
{ "lightpink", rgb(255, 182, 193) },
{ "lightsalmon", rgb(255, 160, 122) },
{ "lightseagreen", rgb( 32, 178, 170) },
{ "lightskyblue", rgb(135, 206, 250) },
{ "lightslategray", rgb(119, 136, 153) },
{ "lightslategrey", rgb(119, 136, 153) },
{ "lightsteelblue", rgb(176, 196, 222) },
{ "lightyellow", rgb(255, 255, 224) },
{ "lime", rgb( 0, 255, 0) },
{ "limegreen", rgb( 50, 205, 50) },
{ "linen", rgb(250, 240, 230) },
{ "magenta", rgb(255, 0, 255) },
{ "maroon", rgb(128, 0, 0) },
{ "mediumaquamarine", rgb(102, 205, 170) },
{ "mediumblue", rgb( 0, 0, 205) },
{ "mediumorchid", rgb(186, 85, 211) },
{ "mediumpurple", rgb(147, 112, 219) },
{ "mediumseagreen", rgb( 60, 179, 113) },
{ "mediumslateblue", rgb(123, 104, 238) },
{ "mediumspringgreen", rgb( 0, 250, 154) },
{ "mediumturquoise", rgb( 72, 209, 204) },
{ "mediumvioletred", rgb(199, 21, 133) },
{ "midnightblue", rgb( 25, 25, 112) },
{ "mintcream", rgb(245, 255, 250) },
{ "mistyrose", rgb(255, 228, 225) },
{ "moccasin", rgb(255, 228, 181) },
{ "navajowhite", rgb(255, 222, 173) },
{ "navy", rgb( 0, 0, 128) },
{ "oldlace", rgb(253, 245, 230) },
{ "olive", rgb(128, 128, 0) },
{ "olivedrab", rgb(107, 142, 35) },
{ "orange", rgb(255, 165, 0) },
{ "orangered", rgb(255, 69, 0) },
{ "orchid", rgb(218, 112, 214) },
{ "palegoldenrod", rgb(238, 232, 170) },
{ "palegreen", rgb(152, 251, 152) },
{ "paleturquoise", rgb(175, 238, 238) },
{ "palevioletred", rgb(219, 112, 147) },
{ "papayawhip", rgb(255, 239, 213) },
{ "peachpuff", rgb(255, 218, 185) },
{ "peru", rgb(205, 133, 63) },
{ "pink", rgb(255, 192, 203) },
{ "plum", rgb(221, 160, 221) },
{ "powderblue", rgb(176, 224, 230) },
{ "purple", rgb(128, 0, 128) },
{ "red", rgb(255, 0, 0) },
{ "rosybrown", rgb(188, 143, 143) },
{ "royalblue", rgb( 65, 105, 225) },
{ "saddlebrown", rgb(139, 69, 19) },
{ "salmon", rgb(250, 128, 114) },
{ "sandybrown", rgb(244, 164, 96) },
{ "seagreen", rgb( 46, 139, 87) },
{ "seashell", rgb(255, 245, 238) },
{ "sienna", rgb(160, 82, 45) },
{ "silver", rgb(192, 192, 192) },
{ "skyblue", rgb(135, 206, 235) },
{ "slateblue", rgb(106, 90, 205) },
{ "slategray", rgb(112, 128, 144) },
{ "slategrey", rgb(112, 128, 144) },
{ "snow", rgb(255, 250, 250) },
{ "springgreen", rgb( 0, 255, 127) },
{ "steelblue", rgb( 70, 130, 180) },
{ "tan", rgb(210, 180, 140) },
{ "teal", rgb( 0, 128, 128) },
{ "thistle", rgb(216, 191, 216) },
{ "tomato", rgb(255, 99, 71) },
{ "transparent", 0 },
{ "turquoise", rgb( 64, 224, 208) },
{ "violet", rgb(238, 130, 238) },
{ "wheat", rgb(245, 222, 179) },
{ "white", rgb(255, 255, 255) },
{ "whitesmoke", rgb(245, 245, 245) },
{ "yellow", rgb(255, 255, 0) },
{ "yellowgreen", rgb(154, 205, 50) }
};
static const int rgbTblSize = sizeof(rgbTbl) / sizeof(RGBData);
#undef rgb
QT_BEGIN_INCLUDE_NAMESPACE
#include <stdlib.h>
QT_END_INCLUDE_NAMESPACE
#if defined(Q_C_CALLBACKS)
extern "C" {
#endif
#ifdef Q_OS_WINCE
static int __cdecl rgb_cmp(const void *d1, const void *d2)
#else
static int rgb_cmp(const void *d1, const void *d2)
#endif
{
return qstricmp(((RGBData *)d1)->name, ((RGBData *)d2)->name);
}
#if defined(Q_C_CALLBACKS)
}
#endif
static bool get_named_rgb(const char *name, QRgb *rgb)
{
RGBData x;
x.name = name;
RGBData *r = (RGBData*)bsearch(&x, rgbTbl, rgbTblSize, sizeof(RGBData), rgb_cmp);
if (r) {
*rgb = r->value;
return true;
}
return false;
}
bool qt_get_named_rgb(const char *name, QRgb* rgb)
{
int len = int(strlen(name));
if(len > 255)
return false;
char name_no_space[256];
int pos = 0;
for(int i = 0; i < len; i++) {
if(name[i] != '\t' && name[i] != ' ')
name_no_space[pos++] = name[i];
}
name_no_space[pos] = 0;
return get_named_rgb(name_no_space, rgb);
}
// bool qt_get_named_rgb(const QChar *name, int len, QRgb *rgb)
// {
// if(len > 255)
// return false;
// char name_no_space[256];
// int pos = 0;
// for(int i = 0; i < len; i++) {
// if(name[i] != QLatin1Char('\t') && name[i] != QLatin1Char(' '))
// name_no_space[pos++] = name[i].toLatin1();
// }
// name_no_space[pos] = 0;
// return get_named_rgb(name_no_space, rgb);
// }
//
//
// uint qt_get_rgb_val(const char *name)
// {
// QRgb r = 0;
// qt_get_named_rgb(name,&r);
// return r;
// }
//
// QStringList qt_get_colornames()
// {
// int i = 0;
// QStringList lst;
// for (i = 0; i < rgbTblSize; i++)
// lst << QLatin1String(rgbTbl[i].name);
// return lst;
// }
//
#else
bool qt_get_named_rgb(const char *, QRgb*)
{
return false;
}
uint qt_get_rgb_val(const char *)
{
return 0;
}
// QStringList qt_get_colornames()
// {
// return QStringList();
// }
#endif // QT_NO_COLORNAMES
QT_END_NAMESPACE
| [
"zhangyinquan@0feb242a-2539-11de-a0d7-251e5865a1c7"
] | [
[
[
1,
391
]
]
] |
e134a271f4771aff31df783ae682e58719f7c32d | 336ec5b80085d8bdd65d5ad2384507e6db6536bd | /libraries/iosrv/server/session.cpp | c82f0f7c7bb4514d63d690d8b6db1ecf1cb9b3b0 | [] | no_license | springxu0800/oss.FCL.sf.os.fshell | 1c2051076cfd284553a0845cc86e617c1badc188 | 30d5fcf516eed5ae7a5379a6a469c75f93a1345b | refs/heads/master | 2021-06-04T18:53:26.010490 | 2010-12-07T17:29:09 | 2010-12-07T17:29:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,336 | cpp | // session.cpp
//
// Copyright (c) 2006 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Accenture - Initial contribution
//
#include "server.h"
#include "pipe.h"
#include "console.h"
#include "file.h"
#include "null.h"
#include "persistentconsole.h"
#include "readwrite.h"
#include "clientserver.h"
#include "session.h"
CIoSession::CIoSession()
{
}
CIoServer& CIoSession::Server()
{
#ifdef EKA2
return *static_cast<CIoServer*>(const_cast<CServer2*>(CSession2::Server()));
#else
return *static_cast<CIoServer*>(const_cast<CServer*>(CSharableSession::Server()));
#endif
}
#ifdef EKA2
void CIoSession::CreateL()
#else
void CIoSession::CreateL(const CServer& aServer)
#endif
{
#ifndef EKA2
CSharableSession::CreateL(aServer); // does not leave
#endif
iHandles = CObjectIx::NewL();
Server().AddSession();
}
CIoSession::~CIoSession()
{
delete iFindByNameMatch;
if (iHandles)
{
const TInt maxNumObjects = iHandles->Count();
for (TInt i = 0; i < maxNumObjects; ++i)
{
CIoObject* obj = static_cast<CIoObject*>((*iHandles)[i]);
if (obj != NULL)
{
obj->SessionClosed(*this);
}
}
}
Server().DropSession();
delete iHandles;
LOG(CIoLog::Printf(_L("CIoSession 0x%08x destroyed\r\n"), this));
}
void CIoSession::ServiceL(const RMsg& aMessage)
{
LOG(CIoLog::StartServiceLC(aMessage));
switch (aMessage.Function())
{
case EIoHandleSetOwner:
{
TThreadId owningThread(aMessage.Int0());
FindReadWriteObjectL(aMessage.Int3(), aMessage).SetOwnerL(owningThread);
Complete(aMessage, KErrNone);
break;
}
case EIoHandleSetUnderlyingConsole:
{
FindReadWriteObjectL(aMessage.Int3(), aMessage).SetConsole(FindConsoleL(aMessage.Int0(), aMessage));
Complete(aMessage, KErrNone);
break;
}
case EIoHandleAttachedToConsole:
{
CIoReadWriteObject& obj = FindReadWriteObjectL(aMessage.Int3(), aMessage);
if (obj.IsType(RIoHandle::EReadObject))
{
Complete(aMessage, MIoReadEndPoint::AttachedToConsole((MIoReadEndPoint*)obj.EndPoint()));
}
else
{
Complete(aMessage, MIoWriteEndPoint::AttachedToConsole((MIoWriteEndPoint*)obj.EndPoint()));
}
break;
}
case EIoCreateReader:
{
CIoReadObject& readObj = Server().CreateReadObjLC();
LOG(CIoLog::Printf(_L("id: %d"), readObj.Id()));
CreateHandleL(readObj, ETrue, aMessage);
break;
}
case EIoOpenReaderByThreadId:
{
TThreadId clientThreadId(ClientThreadIdL(aMessage));
CIoReadObject* readObj = Server().NextReadObj(clientThreadId);
if (readObj == NULL)
{
Complete(aMessage, KErrNotFound);
}
else
{
#ifdef EKA2
LOG(CIoLog::Printf(_L("thread id: %Lu"), clientThreadId.Id()));
#else
LOG(CIoLog::Printf(_L("thread id: %u"), clientThreadId));
#endif
OBJ_NAME(*readObj);
LOG(CIoLog::Printf(_L("name: \"%S\""), &objName));
User::LeaveIfError(readObj->Open(clientThreadId));
CleanupClosePushL(*readObj);
CreateHandleL(*readObj, EFalse, aMessage);
CleanupStack::Pop();
}
break;
}
case EIoOpenReaderByExplicitThreadId:
{
TThreadId clientThreadId;
TPckg<TThreadId> clientThreadIdPckg(clientThreadId);
MessageReadL(aMessage, 0, clientThreadIdPckg);
CIoReadObject* readObj = Server().NextReadObj(clientThreadId);
if (readObj == NULL)
{
Complete(aMessage, KErrNotFound);
}
else
{
#ifdef EKA2
LOG(CIoLog::Printf(_L("thread id: %Lu"), clientThreadId.Id()));
#else
LOG(CIoLog::Printf(_L("thread id: %u"), clientThreadId));
#endif
OBJ_NAME(*readObj);
LOG(CIoLog::Printf(_L("name: \"%S\""), &objName));
User::LeaveIfError(readObj->Open(clientThreadId));
CleanupClosePushL(*readObj);
CreateHandleL(*readObj, EFalse, aMessage);
CleanupStack::Pop();
}
break;
}
case EIoDuplicateReader:
{
CIoReadObject& readObj = FindReadObjectL(aMessage.Int3(), aMessage);
CIoReadObject& duplicateReadObj = FindReadObjectL(aMessage.Int0(), aMessage);
readObj.DuplicateL(duplicateReadObj);
LOG(CIoLog::Printf(_L("Duplicating read object 0x%08x (id: %d) from 0x%08x (id: %d)"), &readObj, readObj.Id(), &duplicateReadObj, duplicateReadObj.Id()));
Complete(aMessage, KErrNone);
break;
}
case EIoDuplicateReaderHandleFromThread:
{
TThreadId threadId(aMessage.Int0());
CIoReadObject& readObj = FindReadObjectL(aMessage.Int3(), aMessage);
CIoReadObject* otherThreadObj = Server().LastOpenedReadObj(threadId);
if (otherThreadObj)
{
LOG(CIoLog::Printf(_L("Duplicating read object 0x%08x (id: %d) from 0x%08x (id: %d)"), &readObj, readObj.Id(), otherThreadObj, otherThreadObj->Id()));
readObj.DuplicateL(*otherThreadObj);
}
else
{
User::Leave(KErrNotFound);
}
Complete(aMessage, KErrNone);
break;
}
case EIoCreateWriter:
{
CIoWriteObject& writeObj = Server().CreateWriteObjLC();
LOG(CIoLog::Printf(_L("id: %d"), writeObj.Id()));
CreateHandleL(writeObj, ETrue, aMessage);
break;
}
case EIoOpenWriterByThreadId:
{
TThreadId clientThreadId(ClientThreadIdL(aMessage));
CIoWriteObject* writeObj = Server().NextWriteObj(clientThreadId);
if (writeObj == NULL)
{
Complete(aMessage, KErrNotFound);
}
else
{
LOG(CIoLog::Printf(_L("thread id: %u"), TUint(clientThreadId)));
OBJ_NAME(*writeObj);
LOG(CIoLog::Printf(_L("name: \"%S\""), &objName));
User::LeaveIfError(writeObj->Open(clientThreadId));
CleanupClosePushL(*writeObj);
CreateHandleL(*writeObj, EFalse, aMessage);
CleanupStack::Pop();
}
break;
}
case EIoOpenWriterByExplicitThreadId:
{
TThreadId clientThreadId;
TPckg<TThreadId> clientThreadIdPckg(clientThreadId);
MessageReadL(aMessage, 0, clientThreadIdPckg);
CIoWriteObject* writeObj = Server().NextWriteObj(clientThreadId);
if (writeObj == NULL)
{
Complete(aMessage, KErrNotFound);
}
else
{
LOG(CIoLog::Printf(_L("thread id: %u"), TUint(clientThreadId)));
OBJ_NAME(*writeObj);
LOG(CIoLog::Printf(_L("name: \"%S\""), &objName));
User::LeaveIfError(writeObj->Open(clientThreadId));
CleanupClosePushL(*writeObj);
CreateHandleL(*writeObj, EFalse, aMessage);
CleanupStack::Pop();
}
break;
}
case EIoDuplicateWriter:
{
CIoWriteObject& writeObj = FindWriteObjectL(aMessage.Int3(), aMessage);
CIoWriteObject& duplicateWriteObj = FindWriteObjectL(aMessage.Int0(), aMessage);
writeObj.DuplicateL(duplicateWriteObj);
LOG(CIoLog::Printf(_L("Duplicating write object 0x%08x (id: %d) from 0x%08x (id: %d)"), &writeObj, writeObj.Id(), &duplicateWriteObj, duplicateWriteObj.Id()));
Complete(aMessage, KErrNone);
break;
}
case EIoDuplicateWriterHandleFromThread:
{
TThreadId threadId(aMessage.Int0());
CIoWriteObject& writeObj = FindWriteObjectL(aMessage.Int3(), aMessage);
CIoWriteObject* otherThreadObj = Server().LastOpenedWriteObj(threadId);
if (otherThreadObj)
{
LOG(CIoLog::Printf(_L("Duplicating write object 0x%08x (id: %d) from 0x%08x (id: %d)"), &writeObj, writeObj.Id(), otherThreadObj, otherThreadObj->Id()));
writeObj.DuplicateL(*otherThreadObj);
}
else
{
User::Leave(KErrNotFound);
}
Complete(aMessage, KErrNone);
break;
}
case EIoSetReadWriteMode:
{
FindReadWriteObjectL(aMessage.Int3(), aMessage).SetModeL(aMessage);
break;
}
case EIoSetReadMode:
{
TInt mode(aMessage.Int0());
if ((mode >= RIoReadHandle::EFull) && (mode <= RIoReadHandle::EOneOrMore))
{
FindReadObjectL(aMessage.Int3(), aMessage).SetReadMode((RIoReadHandle::TReadMode)mode);
Complete(aMessage, KErrNone);
}
else
{
Complete(aMessage, KErrNotSupported);
}
break;
}
case EIoSetReaderToForeground:
{
FindReadObjectL(aMessage.Int3(), aMessage).SetToForegroundL();
Complete(aMessage, KErrNone);
break;
}
case EIoRead:
{
FindReadObjectL(aMessage.Int3(), aMessage).ReadL(aMessage);
break;
}
case EIoReadCancel:
{
FindReadObjectL(aMessage.Int3(), aMessage).ReadCancel(*this);
Complete(aMessage, KErrNone);
break;
}
case EIoSetLineSeparator:
{
FindReadObjectL(aMessage.Int3(), aMessage).SetLineSeparatorL(aMessage);
break;
}
case EIoWrite:
{
FindWriteObjectL(aMessage.Int3(), aMessage).WriteL(aMessage);
break;
}
case EIoWriteCancel:
{
FindWriteObjectL(aMessage.Int3(), aMessage).WriteCancel(*this);
Complete(aMessage, KErrNone);
break;
}
case EIoIsForegroundReader:
{
Complete(aMessage, FindReadObjectL(aMessage.Int3(), aMessage).IsForegroundL());
break;
}
case EIoConsoleWaitForKey:
{
FindReadObjectL(aMessage.Int3(), aMessage).ReadKeyL(aMessage);
break;
}
case EIoConsoleWaitForKeyCancel:
{
FindReadObjectL(aMessage.Int3(), aMessage).ReadKeyCancel(*this);
Complete(aMessage, KErrNone);
break;
}
case EIoConsoleCaptureKey:
{
FindReadObjectL(aMessage.Int3(), aMessage).CaptureKeyL(aMessage);
break;
}
case EIoConsoleCancelCaptureKey:
{
FindReadObjectL(aMessage.Int3(), aMessage).CancelCaptureKey(aMessage);
break;
}
case EIoConsoleCaptureAllKeys:
{
FindReadObjectL(aMessage.Int3(), aMessage).CaptureAllKeys(aMessage);
break;
}
case EIoConsoleCancelCaptureAllKeys:
{
FindReadObjectL(aMessage.Int3(), aMessage).CancelCaptureAllKeys(aMessage);
break;
}
case EIoConsoleCursorPos:
{
FindWriteObjectL(aMessage.Int3(), aMessage).CursorPosL(aMessage);
break;
}
case EIoConsoleSetCursorPosAbs:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetCursorPosAbsL(aMessage);
break;
}
case EIoConsoleSetCursorPosRel:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetCursorPosRelL(aMessage);
break;
}
case EIoConsoleSetCursorHeight:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetCursorHeightL(aMessage);
break;
}
case EIoConsoleSetTitle:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetTitleL(aMessage);
break;
}
case EIoConsoleClearScreen:
{
FindWriteObjectL(aMessage.Int3(), aMessage).ClearScreen(aMessage);
break;
}
case EIoConsoleClearToEndOfLine:
{
FindWriteObjectL(aMessage.Int3(), aMessage).ClearToEndOfLine(aMessage);
break;
}
case EIoConsoleScreenSize:
{
FindWriteObjectL(aMessage.Int3(), aMessage).ScreenSizeL(aMessage);
break;
}
case EIoConsoleSetAttributes:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetAttributesL(aMessage);
break;
}
case EIoCreatePipe:
{
CIoPipe& pipe = Server().CreatePipeLC();
CreateHandleL(pipe, ETrue, aMessage);
break;
}
case EIoHandleClose:
{
const TInt handle = aMessage.Int3();
LOG(CIoLog::Printf(_L("handle: %d"), handle));
CIoObject* obj = (CIoObject*)iHandles->AtL(handle); // Leaves with KErrBadHandle if not found, which will result in client getting panic'd.
obj->ClosedBy(*this);
iHandles->Remove(handle);
Complete(aMessage, KErrNone);
break;
}
case EIoEndPointAttachReader:
{
CIoEndPoint& endPoint = FindEndPointL(aMessage.Int3(), aMessage);
CIoReadObject& readObj = FindReadObjectL(aMessage.Int0(), aMessage);
RIoEndPoint::TReadMode mode = (RIoEndPoint::TReadMode)aMessage.Int1();
LOG(CIoLog::Printf(_L("read obj id: %d, address: 0x%08x"), readObj.Id(), &readObj));
LOG(CIoLog::Printf(_L("end point handle: %d, address: 0x%08x"), aMessage.Int3(), &endPoint));
readObj.AttachL(endPoint, mode);
Complete(aMessage, KErrNone);
break;
}
case EIoEndPointAttachWriter:
{
CIoEndPoint& endPoint = FindEndPointL(aMessage.Int3(), aMessage);
CIoWriteObject& writeObj = FindWriteObjectL(aMessage.Int0(), aMessage);
LOG(CIoLog::Printf(_L("write obj id: %d, address: 0x%08x"), writeObj.Id(), &writeObj));
LOG(CIoLog::Printf(_L("end point handle: %d, address: 0x%08x"), aMessage.Int3(), &endPoint));
writeObj.AttachL(endPoint);
Complete(aMessage, KErrNone);
break;
}
case EIoEndPointSetForegroundReadHandle:
{
CIoEndPoint& endPoint = FindEndPointL(aMessage.Int3(), aMessage);
CIoReadObject& readObj = FindReadObjectL(aMessage.Int0(), aMessage);
LOG(CIoLog::Printf(_L("read obj id: %d, address: 0x%08x"), readObj.Id(), &readObj));
LOG(CIoLog::Printf(_L("end point handle: %d, address: 0x%08x"), aMessage.Int3(), &endPoint));
endPoint.IorepSetForegroundReaderL(readObj);
Complete(aMessage, KErrNone);
break;
}
case EIoCreateConsole:
{
HBufC* titleBuf = HBufC::NewLC(DesLengthL(aMessage, 0));
TPtr titlePtr(titleBuf->Des());
MessageReadL(aMessage, 0, titlePtr);
TPckgBuf<TConsoleCreateParams> paramsPckg;
MessageReadL(aMessage, 1, paramsPckg);
HBufC* implBuf = HBufC::NewLC(DesLengthL(aMessage, 2));
TPtr implPtr(implBuf->Des());
MessageReadL(aMessage, 2, implPtr);
CIoConsole* underlyingCons = NULL;
if (paramsPckg().iUnderlyingConsoleHandle != KNullHandle)
{
underlyingCons = &FindConsoleL(paramsPckg().iUnderlyingConsoleHandle, aMessage);
}
CIoConsole& console = Server().CreateConsoleLC(*implBuf, *titleBuf, paramsPckg().iSize, underlyingCons, paramsPckg().iOptions);
CreateHandleL(console, ETrue, aMessage); //pops console
CleanupStack::PopAndDestroy(2, titleBuf);
break;
}
case EIoOpenConsole:
{
CIoConsole* console = FindReadWriteObjectL(aMessage.Int0(), aMessage).Console();
if (console)
{
User::LeaveIfError(console->Open());
CleanupClosePushL(*console);
CreateHandleL(*console, EFalse, aMessage);
CleanupStack::Pop();
}
else
{
Complete(aMessage, KErrNotFound);
}
break;
}
case EIoConsoleImplementation:
{
TInt clientDesLen = MaxDesLengthL(aMessage, 0);
const TDesC& impl(FindConsoleL(aMessage.Int3(), aMessage).Implementation());
MessageWriteL(aMessage, 0, impl.Left(clientDesLen));
Complete(aMessage, impl.Length() > clientDesLen ? KErrOverflow : KErrNone);
break;
}
case EIoCreateFile:
{
HBufC* fileNameBuf = HBufC::NewLC(DesLengthL(aMessage, 0));
TPtr fileNamePtr(fileNameBuf->Des());
MessageReadL(aMessage, 0, fileNamePtr);
CIoFile& file = Server().CreateFileLC(*fileNameBuf, (RIoFile::TMode)aMessage.Int1());
CreateHandleL(file, ETrue, aMessage);
CleanupStack::PopAndDestroy(fileNameBuf);
break;
}
case EIoCreateNull:
{
CIoNull& null = Server().CreateNullLC();
CreateHandleL(null, ETrue, aMessage);
break;
}
case EIoSetObjectName:
{
CObject* obj = iHandles->AtL(aMessage.Int0());
HBufC* name = HBufC::NewLC(DesLengthL(aMessage, 1));
TPtr namePtr(name->Des());
MessageReadL(aMessage, 1, namePtr);
LOG(CIoLog::Printf(_L("Setting object (handle: %d, address: 0x%08x) to \"%S\""), aMessage.Int0(), &obj, name));
TPtrC truncatedName(name->Left(KMaxName));
obj->SetName(&truncatedName);
CleanupStack::PopAndDestroy(name);
Complete(aMessage, KErrNone);
break;
}
case EIoCreatePersistentConsole:
{
HBufC* nameBuf = HBufC::NewLC(DesLengthL(aMessage, 1));
TPtr namePtr(nameBuf->Des());
MessageReadL(aMessage, 0, namePtr);
HBufC* titleBuf = HBufC::NewLC(DesLengthL(aMessage, 0));
TPtr titlePtr(titleBuf->Des());
MessageReadL(aMessage, 1, titlePtr);
CIoPersistentConsole& pcons = Server().CreatePersistentConsoleLC(*nameBuf, *titleBuf, aMessage);
CreateHandleL(pcons, ETrue, aMessage);
CleanupStack::PopAndDestroy(2, nameBuf);
break;
}
case EIoOpenPersistentConsoleByName:
{
HBufC* nameBuf = HBufC::NewLC(DesLengthL(aMessage, 0));
TPtr namePtr(nameBuf->Des());
MessageReadL(aMessage, 0, namePtr);
CIoPersistentConsole& pcons = Server().FindPersistentConsoleL(*nameBuf);
User::LeaveIfError(pcons.Open());
CleanupClosePushL(pcons);
CreateHandleL(pcons, EFalse, aMessage);
CleanupStack::Pop(&pcons);
CleanupStack::PopAndDestroy(nameBuf);
break;
};
case EIoPersistentConsoleAttachReadEndPoint:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
CIoEndPoint& endPoint = FindEndPointL(aMessage.Int0(), aMessage);
RIoPersistentConsole::TCloseBehaviour onClose = (RIoPersistentConsole::TCloseBehaviour)aMessage.Int1();
pcons.AttachTransientReaderL(endPoint, onClose == RIoPersistentConsole::EDetachOnHandleClose ? this : NULL);
Complete(aMessage, KErrNone);
break;
}
case EIoPersistentConsoleAttachWriteEndPoint:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
CIoEndPoint& endPoint = FindEndPointL(aMessage.Int0(), aMessage);
RIoPersistentConsole::TCloseBehaviour onClose = (RIoPersistentConsole::TCloseBehaviour)aMessage.Int1();
pcons.AttachTransientWriterL(endPoint, onClose == RIoPersistentConsole::EDetachOnHandleClose ? this : NULL);
Complete(aMessage, KErrNone);
break;
}
case EIoPersistentConsoleDetachReadEndPoint:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.DetachTransientReader();
Complete(aMessage, KErrNone);
break;
}
case EIoPersistentConsoleDetachWriteEndPoint:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.DetachTransientWriter();
Complete(aMessage, KErrNone);
break;
}
case EIoPersistentConsoleNotifyReadDetach:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.NotifyReadDetachL(aMessage);
break;
}
case EIoPersistentConsoleNotifyWriteDetach:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.NotifyWriteDetachL(aMessage);
break;
}
case EIoPersistentConsoleCancelNotifyReadDetach:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.CancelNotifyReadDetach((TRequestStatus*)aMessage.Int0());
break;
}
case EIoPersistentConsoleCancelNotifyWriteDetach:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
pcons.CancelNotifyWriteDetach((TRequestStatus*)aMessage.Int0());
break;
}
case EIoPersistentConsoleGetAttachedNames:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
MessageWriteL(aMessage, 0, pcons.TransientReaderName());
MessageWriteL(aMessage, 1, pcons.TransientWriterName());
Complete(aMessage, KErrNone);
break;
}
case EIoPersistentConsoleGetCreatorThreadId:
{
CIoPersistentConsole& pcons = FindPersistentConsoleL(aMessage.Int3(), aMessage);
MessageWriteL(aMessage, 0, TPckg<TThreadId>(pcons.Creator()));
Complete(aMessage, KErrNone);
break;
}
case EIoHandleIsType:
{
CIoObject& obj = FindObjectL(aMessage.Int3());
Complete(aMessage, obj.IsType((RIoHandle::TType)aMessage.Int0()));
break;
}
case EIoFindFirstHandle:
{
iFindByNameType = (RIoHandle::TType)aMessage.Int0();
delete iFindByNameMatch;
iFindByNameMatch = NULL;
iFindByNameMatch = HBufC::NewL(DesLengthL(aMessage, 1));
TPtr matchPtr(iFindByNameMatch->Des());
MessageReadL(aMessage, 1, matchPtr);
TName foundName;
iFindByNameHandle = 0;
CIoObject* obj = Server().FindObjectByName(iFindByNameType, iFindByNameHandle, *iFindByNameMatch, foundName);
if (obj)
{
MessageWriteL(aMessage, 2, TPckg<TInt>(iFindByNameHandle));
MessageWriteL(aMessage, 3, foundName);
Complete(aMessage, KErrNone);
}
else
{
Complete(aMessage, KErrNotFound);
}
break;
}
case EIoFindNextHandle:
{
if (!(iFindByNameMatch && iFindByNameHandle))
{
PanicClient(aMessage, EPanicFindNextWithNoFindFirst);
break;
}
TName foundName;
CIoObject* obj = Server().FindObjectByName(iFindByNameType, iFindByNameHandle, *iFindByNameMatch, foundName);
if (obj)
{
MessageWriteL(aMessage, 0, TPckg<TInt>(iFindByNameHandle));
MessageWriteL(aMessage, 1, foundName);
Complete(aMessage, KErrNone);
}
else
{
Complete(aMessage, KErrNotFound);
}
break;
}
case EIoOpenFoundHandle:
{
if (!(iFindByNameMatch && iFindByNameHandle))
{
PanicClient(aMessage, EPanicOpenFoundWithNoFind);
break;
}
CIoObject& obj = Server().OpenObjectLC(aMessage.Int0());
CreateHandleL(obj, EFalse, aMessage);
CleanupStack::Pop(&obj);
break;
}
case EIoHandleGetName:
{
CIoObject& obj = FindObjectL(aMessage.Int3());
TName name(obj.Name());
MessageWriteL(aMessage, 0, name.Left(MaxDesLengthL(aMessage, 0)));
Complete(aMessage, MaxDesLengthL(aMessage, 0) < name.Length() ? KErrOverflow : KErrNone);
break;
};
case EIoHandleEquals:
{
CIoObject& tweedledee = FindObjectL(aMessage.Int3());
CIoObject& tweedledum = FindObjectL(aMessage.Int0());
Complete(aMessage, &tweedledee == &tweedledum);
break;
};
case EIoReadHandleNotifyChange:
{
CIoReadObject& readObj = FindReadObjectL(aMessage.Int3(), aMessage);
readObj.NotifyChange(aMessage);
break;
}
case EIoReadHandleCancelNotifyChange:
{
CIoReadObject& readObj = FindReadObjectL(aMessage.Int3(), aMessage);
readObj.CancelNotifyChange(*this);
Complete(aMessage, KErrNone);
break;
}
case EIoSetIsStdErr:
{
FindWriteObjectL(aMessage.Int3(), aMessage).SetIsStdErr((TBool)aMessage.Int0());
Complete(aMessage, KErrNone);
break;
}
default:
{
PanicClient(aMessage, EPanicUnknownOpcode);
break;
}
}
LOG(CleanupStack::PopAndDestroy());
}
void CIoSession::CreateHandleL(CObject& aObject, TBool aDoPop, const RMsg& aMessage)
{
const TInt handle = iHandles->AddL(&aObject);
if (aDoPop)
{
CleanupStack::Pop(&aObject);
}
TPckgC<TInt> handlePckg(handle);
TRAPD(err, MessageWriteL(aMessage, 3, handlePckg));
if (err)
{
iHandles->Remove(handle);
User::Leave(err);
}
LOG(CIoLog::Printf(_L("Created handle %d"), handle));
Complete(aMessage, err);
}
CIoObject& CIoSession::FindObjectL(TInt aHandle)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
return *obj;
}
CIoEndPoint& CIoSession::FindEndPointL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EEndPoint), PanicClient(aMessage, EPanicNotAnEndPoint));
return *static_cast<CIoEndPoint*>(obj);
}
CIoPipe& CIoSession::FindPipeL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EPipe), PanicClient(aMessage, EPanicNotAPipe));
return *static_cast<CIoPipe*>(obj);
}
CIoConsole& CIoSession::FindConsoleL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EConsole), PanicClient(aMessage, EPanicNotAConsole));
return *static_cast<CIoConsole*>(obj);
}
CIoPersistentConsole& CIoSession::FindPersistentConsoleL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EPersistentConsole), PanicClient(aMessage, EPanicNotAPersistentConsole));
return *static_cast<CIoPersistentConsole*>(obj);
}
CIoReadWriteObject& CIoSession::FindReadWriteObjectL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EReadWriteObject), PanicClient(aMessage, EPanicNotAReadWriteObject));
return *static_cast<CIoReadWriteObject*>(obj);
}
CIoReadObject& CIoSession::FindReadObjectL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EReadObject), PanicClient(aMessage, EPanicNotAReadObject));
return *static_cast<CIoReadObject*>(obj);
}
CIoWriteObject& CIoSession::FindWriteObjectL(TInt aHandle, const RMsg& aMessage)
{
CIoObject* obj = static_cast<CIoObject*>(iHandles->AtL(aHandle));
__ASSERT_ALWAYS(obj->IsType(RIoHandle::EWriteObject), PanicClient(aMessage, EPanicNotAWriteObject));
return *static_cast<CIoWriteObject*>(obj);
}
void CIoSession::Complete(const RMsg& aMessage, TInt aError)
{
LOG(CIoLog::LogCompletion(aMessage, aError));
aMessage.Complete(aError);
}
| [
"[email protected]"
] | [
[
[
1,
800
]
]
] |
e3881fef745afeb749ec44a557cadd370aff1621 | bef7d0477a5cac485b4b3921a718394d5c2cf700 | /dingus/dingus/resource/CubeTextureCreator.h | 66670133fd563176cfec4d32b7160cb8f40dc4f5 | [
"MIT"
] | permissive | TomLeeLive/aras-p-dingus | ed91127790a604e0813cd4704acba742d3485400 | 22ef90c2bf01afd53c0b5b045f4dd0b59fe83009 | refs/heads/master | 2023-04-19T20:45:14.410448 | 2011-10-04T10:51:13 | 2011-10-04T10:51:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,417 | h | // --------------------------------------------------------------------------
// Dingus project - a collection of subsystems for game/graphics applications
// --------------------------------------------------------------------------
#ifndef __CUBE_TEXTURE_CREATOR_H
#define __CUBE_TEXTURE_CREATOR_H
namespace dingus {
class ICubeTextureCreator : public CRefCounted {
public:
typedef DingusSmartPtr<ICubeTextureCreator> TSharedPtr;
public:
virtual ~ICubeTextureCreator() = 0 { }
virtual IDirect3DCubeTexture9* createTexture() = 0;
};
class CAbstractCubeTextureCreator : public ICubeTextureCreator {
public:
CAbstractCubeTextureCreator( DWORD usage, D3DFORMAT format, D3DPOOL pool )
: mUsage(usage), mFormat(format), mPool(pool) { }
protected:
DWORD getUsage() const { return mUsage; }
D3DFORMAT getFormat() const { return mFormat; }
D3DPOOL getPool() const { return mPool; }
private:
DWORD mUsage;
D3DFORMAT mFormat;
D3DPOOL mPool;
};
/// Creates fixed size cube texture
class CFixedCubeTextureCreator : public CAbstractCubeTextureCreator {
public:
CFixedCubeTextureCreator( int size, int levels, DWORD usage, D3DFORMAT format, D3DPOOL pool )
: CAbstractCubeTextureCreator(usage,format,pool), mSize(size), mLevels(levels) { }
virtual IDirect3DCubeTexture9* createTexture();
private:
int mSize, mLevels;
};
}; // namespace
#endif
| [
"[email protected]"
] | [
[
[
1,
51
]
]
] |
a37b25b835b4dc603c89610dccc090a9e6906dc3 | 6c8c4728e608a4badd88de181910a294be56953a | /UiModule/Inworld/Menus/MenuNode.h | 7aa842f583e5672578bc725c978b48dbf061707c | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | caocao/naali | 29c544e121703221fe9c90b5c20b3480442875ef | 67c5aa85fa357f7aae9869215f840af4b0e58897 | refs/heads/master | 2021-01-21T00:25:27.447991 | 2010-03-22T15:04:19 | 2010-03-22T15:04:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,056 | h | // For conditions of distribution and use, see copyright notice in license.txt
#ifndef incl_UiModule_MenuNode_h
#define incl_UiModule_MenuNode_h
#include <QGraphicsProxyWidget>
#include <QParallelAnimationGroup>
#include <QUuid>
#include <QPushButton>
#include <QString>
#include <QPointF>
#include "ui_MenuNode.h"
#define MOVE_ANIM_LENGTH 400
#define RESIZE_ANIM_LENGTH 200
#define ADJUST_ANIM_LENGTH 150
namespace CoreUi
{
class GroupNode;
class MenuNode : public QGraphicsProxyWidget, protected Ui::MenuNode
{
Q_OBJECT
public:
MenuNode(const QString& node_name, QUuid id = QUuid());
public slots:
QPushButton *GetMenuButton();
QUuid GetID();
void EnableText();
void DisableText();
void SetTreeDepth(int tree_depth) { tree_depth_ = tree_depth; }
int GetTreeDepth() { return tree_depth_; }
int GetExpandedWidth() { return expanded_width_; }
QPointF GetShrunkenPos(){ return shrunken_pos_; }
void SetShrunkenPos(QPointF shrunken_pos){ shrunken_pos_ = shrunken_pos; }
QPointF GetExpandedPos(){ return expanded_pos_; }
void SetExpandedPos(QPointF expanded_pos){ expanded_pos_ = expanded_pos; }
QPointF GetOriginalPos(){ return original_pos_; }
void SetOriginalPos(QPointF original_pos){ original_pos_ = original_pos; }
// Reimplement in subclass
virtual void NodeClicked() = 0;
virtual void AddChildNode(MenuNode *node) = 0;
protected:
QString node_name_;
QUuid id_;
QWidget *widget_;
QPointF original_pos_;
QPointF expanded_pos_;
QPointF shrunken_pos_;
int tree_depth_;
int expanded_width_;
signals:
void ActionButtonClicked(QUuid);
void NodeGroupClicked(GroupNode *clicked_node, QParallelAnimationGroup *move_animations, QParallelAnimationGroup *size_animations);
};
}
#endif
| [
"[email protected]@5b2332b8-efa3-11de-8684-7d64432d61a3"
] | [
[
[
1,
74
]
]
] |
aed35348505227dbcd710897a0fd4c995470f4fe | 299a1b0fca9e1de3858a5ebeaf63be6dc3a02b48 | /tags/051101b/dingus/dingus/stdafx.h | e7804c8cf5f54dac13d51c158e19c4b764f8c890 | [] | no_license | BackupTheBerlios/dingus-svn | 331d7546a6e7a5a3cb38ffb106e57b224efbf5df | 1223efcf4c2079f58860d7fa685fa5ded8f24f32 | refs/heads/master | 2016-09-05T22:15:57.658243 | 2006-09-02T10:10:47 | 2006-09-02T10:10:47 | 40,673,143 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,018 | h | // --------------------------------------------------------------------------
// Dingus project - a collection of subsystems for game/graphics applications
// --------------------------------------------------------------------------
#ifndef __DINGUS_STDAFX_H
#define __DINGUS_STDAFX_H
// precompiled headers stuff
#pragma warning(disable:4786)
#pragma warning(disable:4018)
#pragma warning(disable:4511) // copy constructor can't be generated
#pragma warning(disable:4512) // assignment operator can't be generated
#pragma warning(disable:4100) // unreferenced formal parameter
// synch unicode settings
#ifdef _UNICODE
#define UNICODE
#endif
// windows
#ifdef _WINDLL
#define VC_EXTRALEAN
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif
#else
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>
#endif
// STL
#include <list>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <string>
// String type, depending on Unicode settings
#ifdef _UNICODE
typedef std::wstring unistring;
#else
typedef std::string unistring;
#endif
// C libs
#include <cassert>
#include <cmath>
#include <cstring>
#include <malloc.h>
// do NOT include these, so it's less tempting to use rand() etc.
//#include <cstdio>
//#include <cstdlib>
//#include <cstdarg>
// D3D
#include <d3d9.h>
#include <d3dx9.h>
// smart pointers
#include <boost/intrusive_ptr.hpp>
#include <boost/noncopyable.hpp>
// debug memory manager
#define NO_MMGR
#include "utils/mmgr.h"
// common
#include "utils/MemUtil.h"
#include "utils/STLUtils.h"
#include "utils/fastvector.h"
#include "utils/AssertHelper.h"
#include "utils/RefCounted.h"
#include "utils/Timer.h"
#endif
| [
"nearaz@73827abb-88f4-0310-91e6-a2b8c1a3e93d"
] | [
[
[
1,
89
]
]
] |
cc523355143e44e80ae604bd4c6127b9d5be838c | 54319da8732c447b8f196de5e98293083d3acf10 | /qt4_src/test/fxeditor/fxeditor.h | 620018624e80b1f1370b76641b685440c3db4baf | [
"curl"
] | permissive | libfetion/libfetion-gui | 6c0ed30f9b31669048347352b292fbe02e5505f3 | a5912c7ac301830c2953378e58a4d923bc0a0a8d | refs/heads/master | 2021-01-13T02:16:46.031301 | 2010-09-19T10:42:37 | 2010-09-19T10:42:37 | 32,465,618 | 2 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,129 | h | #ifndef FXEDITOR_H
#define FXEDITOR_H
/*******************************
the class FxEditor should be refactoring
maybe should design as the commented declare function and member in this file
*******************************/
#include <QTextEdit>
typedef QPair<QString,QString> mypair;
class FxEditor : public QTextEdit
{
Q_OBJECT
public:
FxEditor(QWidget*parent = 0);
QString toPlainText () const;
// for farther feature: permit user to edit rich text such as <i> <b> and so on.
//QString toHtml() const;
public slots:
void onTextChanged();
public:
void setImagePath(const QString& path);
//QString imagePath() const;
private:
int recaculateCursor(const QString& orihtml,int begin,int end);
/*
int registerSymbol(const QString& symbol,const QString& html);
QString translateSymbol(const QString& text);
QString revertToSymbol(const QString& text)£»
*/
// do not use map
// because it sort the key by char order
//QMap<QString,QString> strToHtml;
QList<mypair> strToHtmlList;
// the image's path
QString _imagePath;
};
#endif // FXEDITOR_H | [
"libfetion@3dff0f8e-6350-0410-ad39-8374e07577ec"
] | [
[
[
1,
42
]
]
] |
49ca54fa07fa64371924e018644737602410f4b7 | 8a8873b129313b24341e8fa88a49052e09c3fa51 | /inc/FileEngineObserver.h | 218e24eaf82f51aeb5c4b5ce8ee4d3ee1e6767bf | [] | no_license | flaithbheartaigh/wapbrowser | ba09f7aa981d65df810dba2156a3f153df071dcf | b0d93ce8517916d23104be608548e93740bace4e | refs/heads/master | 2021-01-10T11:29:49.555342 | 2010-03-08T09:36:03 | 2010-03-08T09:36:03 | 50,261,329 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 665 | h | /*
============================================================================
Name : FileEngineObserver.h
Author : 浮生若茶
Version :
Copyright : Your copyright notice
Description : FileEngineObserver.h - header file
============================================================================
*/
#ifndef FILEENGINEOBSERVER_H
#define FILEENGINEOBSERVER_H
enum TUpdateReason
{
ECopyCompleted,
ECreateFolderCompleted,
ERenameCompleted,
EDeleteCompleted,
ESaveAsCompleted,
};
class MFileEngineEvent
{
public:
virtual void Update(TInt aReason) = 0;
};
#endif // FILEENGINEOBSERVER_H
// End of File
| [
"sungrass.xp@37a08ede-ebbd-11dd-bd7b-b12b6590754f"
] | [
[
[
1,
31
]
]
] |
098f2d567efebbf4352f608c7a74e43c0ac1fa04 | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/Game/Hunter/NewGameVedioUI/UnitTest/include/UnitTestConfig.h | 8f8fe5ac6c75cba1124f42624175f6154f71d787 | [] | no_license | dbabox/aomi | dbfb46c1c9417a8078ec9a516cc9c90fe3773b78 | 4cffc8e59368e82aed997fe0f4dcbd7df626d1d0 | refs/heads/master | 2021-01-13T14:05:10.813348 | 2011-06-07T09:36:41 | 2011-06-07T09:36:41 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,355 | h | #ifndef __Orz_UnitTestConfig_Config__
#define __Orz_UnitTestConfig_Config__
using namespace Orz;
//
//用于作为测试环境的Orz框架
struct UnitTestEnvironmen{
UnitTestEnvironmen(void)
{
using namespace Orz;
//logMgr.reset(new TestLogSystem());
system.reset(new SystemList<boost::mpl::list<SimpleTimerManager, OgreGraphicsManager, CEGUIManager, OISInputManager, FmodSoundManager, PluginsManager> >());
SystemInterface::getSingleton().setParame<bool>("OGRE_NO_OUT", true);
// SystemInterface::getSingleton().setParame<bool>("SILENT", true);
system->init();
Ogre::ConfigFile cf;
cf.load("HunterScene.cfg");
Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::String sec, type, arch;
// go through all specified resource groups
while (seci.hasMoreElements())
{
sec = seci.peekNextKey();
Ogre::ConfigFile::SettingsMultiMap* settings = seci.getNext();
Ogre::ConfigFile::SettingsMultiMap::iterator i;
// go through all resource paths
for (i = settings->begin(); i != settings->end(); i++)
{
type = i->first;
arch = i->second;
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(arch, type, sec);
//Ogre::ResourceGroupManager::getSingleton().addResourceLocation("D:/Test", "FileSystem", "General");
}
}
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("HunterScene");
_timer = ITimerManager::getSingleton().createTimer(boost::bind(&UnitTestEnvironmen::step, this));
_timer->start(0.015f);
test_log.reset(new std::stringstream());
{
namespace logging = boost::log;
namespace fmt = boost::log::formatters;
namespace flt = boost::log::filters;
namespace sinks = boost::log::sinks;
namespace attrs = boost::log::attributes;
namespace src = boost::log::sources;
namespace keywords = boost::log::keywords;
using boost::shared_ptr;
// For now we only create a text output sink:
typedef sinks::synchronous_sink< sinks::text_ostream_backend > text_sink;
shared_ptr< text_sink > pSink(new text_sink);
{
text_sink::locked_backend_ptr pBackend = pSink->locked_backend();
pBackend->add_stream(test_log);
}
Orz::LogSystem::getInstance().addSink(pSink);
pSink->set_filter( flt::attr< Orz::LogSystem::severity_level >("Severity", std::nothrow) == Orz::LogSystem::trace );
}
CEGUI::SchemeManager::getSingleton().create("TaharezLook.scheme");
PluginsManager::getSingleton().loadPlugin("VedioUIComponent");
}
~UnitTestEnvironmen(void)
{
PluginsManager::getSingleton().unloadPlugin("NewGameSceneComponent");
_timer.reset();
system->shutdown();
system.reset();
}
bool step(void)
{
Orz::SystemInterface::getSingleton().exit();
return true;
}
static SystemPtr system;
//static boost::shared_ptr<TestLogSystem> logMgr;
boost::shared_ptr<Timer> _timer;
static boost::shared_ptr< std::stringstream > test_log;
};
// Orz系统
SystemPtr UnitTestEnvironmen::system;
//
boost::shared_ptr< std::stringstream > UnitTestEnvironmen::test_log;
/// 测试日志
//boost::shared_ptr<TestLogSystem> UnitTestEnvironmen::logMgr;
//
//配置全局的环境
BOOST_GLOBAL_FIXTURE( UnitTestEnvironmen )
//
//
//
//
#endif | [
"[email protected]"
] | [
[
[
1,
128
]
]
] |
8f69721dd33ecab9ff50b10777188fba783a7d07 | 69aab86a56c78cdfb51ab19b8f6a71274fb69fba | /Code/inc/MeshManager.h | be76fcb0802e37baba476c6f31be13dc3e125f09 | [
"BSD-3-Clause"
] | permissive | zc5872061/wonderland | 89882b6062b4a2d467553fc9d6da790f4df59a18 | b6e0153eaa65a53abdee2b97e1289a3252b966f1 | refs/heads/master | 2021-01-25T10:44:13.871783 | 2011-08-11T20:12:36 | 2011-08-11T20:12:36 | 38,088,714 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,441 | h | /*
* MeshManager.h
*
* Created on: 2010-12-15
* Author: artur.m
*/
#ifndef MESHMANAGER_H_
#define MESHMANAGER_H_
#include <map>
#include <string>
#include <vector>
#include <memory>
#include "Engine/BasicMesh.h"
#include "CollisionShapes.h"
#include "GameFile.h"
class MeshManager
{
public:
static const std::string MESH_FILE_EXTENSION;
MeshManager();
virtual ~MeshManager();
BasicMesh* getMesh(const std::string& name);
const BaseCollisionShape* getCollisionShape(const std::string& name);
std::auto_ptr<BaseCollisionShape> createCollisionShape(BasicMesh* mesh);
typedef std::vector<GLfloat> FloatDataContainer;
typedef std::vector<GLshort> ShortDataContainer;
void createMesh(const std::string& name,
const FloatDataContainer& vertices,
const FloatDataContainer& uvs,
const FloatDataContainer& normals,
const ShortDataContainer& indices,
CollisionShape type = CS_NONE
);
std::string createHUDPanel(const Rectangle& bounds);
void destroyMesh(const std::string& name);
void destroyMesh(std::auto_ptr<BasicMesh> mesh);
private:
BasicMesh* loadMesh(const std::string& fileName, const std::string meshName);
void loadName(BasicMesh* result, const std::string& readLine);
void loadVertices(BasicMesh* result, const std::string& readLine, GameFile* file);
void loadUvs(BasicMesh* result, const std::string& readLine, GameFile* file);
void loadIndices(BasicMesh* result, const std::string& readLine, GameFile* file);
void loadNormals(BasicMesh* result, const std::string& readLine, GameFile* file);
void setCollision(BasicMesh* result, const std::string& line);
std::auto_ptr<BallCollisionShape> createBallCollisionShape(BasicMesh* source) const;
std::auto_ptr<PlaneCollisionShape> createPlaneCollisionShape(BasicMesh* source) const;
std::auto_ptr<BoxCollisionShape> createBoxCollisionShape(BasicMesh* source) const;
private:
static int s_panelsCount;
static const std::string NAME_SECTION;
static const std::string VERTICES_SECTION;
static const std::string UVS_SECTION;
static const std::string INDICES_SECTION;
static const std::string NORMALS_SECTION;
static const std::string COLLISION_SECTION;
typedef std::map<std::string, BasicMesh*> MeshesContainer;
typedef MeshesContainer::iterator MeshesIter;
MeshesContainer m_meshes;
bool m_valid;
};
#endif /* MESHMANAGER_H_ */
| [
"[email protected]"
] | [
[
[
1,
79
]
]
] |
8877d5811d05aa29f3e518a02fc92126e1de909d | ea2786bfb29ab1522074aa865524600f719b5d60 | /MultimodalSpaceShooter/src/scenes/IntroScene.h | 5f090c801cf9f8880cdbd90403748120efd1d79f | [] | no_license | jeremysingy/multimodal-space-shooter | 90ffda254246d0e3a1e25558aae5a15fed39137f | ca6e28944cdda97285a2caf90e635a73c9e4e5cd | refs/heads/master | 2021-01-19T08:52:52.393679 | 2011-04-12T08:37:03 | 2011-04-12T08:37:03 | 1,467,691 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 916 | h | #ifndef INTROSCENE_H
#define INTROSCENE_H
#include <SFML/Graphics/Text.hpp>
#include "scenes/IScene.h"
#include "input/EventListener.h"
#include "input/MultimodalListener.h"
#include "gui/Menu.h"
#include "gui/ButtonListener.h"
//////////////////////////////////////////////////
/// Introduction scene when the game if launched
//////////////////////////////////////////////////
class IntroScene : public IScene, public ButtonListener
{
public:
IntroScene(SceneManager& sceneManager);
virtual void update(float frameTime);
virtual void draw(sf::RenderTarget& window) const;
virtual void onEvent(const sf::Event& event);
virtual void onMultimodalEvent(Multimodal::Event event);
virtual void onButtonPress(const std::string& buttonId);
private:
sf::Sprite myCursor;
Menu myMenu;
};
#endif // INTROSCENE_H | [
"[email protected]"
] | [
[
[
1,
31
]
]
] |
765dc1270ddd5560d18ea9b535e1a32ae0118198 | 9df2486e5d0489f83cc7dcfb3ccc43374ab2500c | /src/video/img_manager.cpp | 8c2a0ba237dac3cfa596a1e8bb39a74923383c82 | [] | no_license | renardchien/Eta-Chronicles | 27ad4ffb68385ecaafae4f12b0db67c096f62ad1 | d77d54184ec916baeb1ab7cc00ac44005d4f5624 | refs/heads/master | 2021-01-10T19:28:28.394781 | 2011-09-05T14:40:38 | 2011-09-05T14:40:38 | 1,914,623 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 5,839 | cpp | /***************************************************************************
* img_manager.cpp - Image Handler/Manager
*
* Copyright (C) 2003 - 2009 Florian Richter
***************************************************************************/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "../video/img_manager.h"
#include "../video/renderer.h"
#include "../core/i18n.h"
namespace SMC
{
/* *** *** *** *** *** cSaved_Texture *** *** *** *** *** *** *** *** *** *** *** *** */
cSaved_Texture :: cSaved_Texture( void )
{
base = NULL;
pixels = NULL;
width = 0;
height = 0;
format = 0;
min_filter = 0;
mag_filter = 0;
wrap_s = 0;
wrap_t = 0;
}
cSaved_Texture :: ~cSaved_Texture( void )
{
if( pixels )
{
delete[] pixels;
}
}
/* *** *** *** *** *** *** cImage_Manager *** *** *** *** *** *** *** *** *** *** *** */
cImage_Manager :: cImage_Manager( void )
: cObject_Manager<cGL_Surface>()
{
high_texture_id = 0;
}
cImage_Manager :: ~cImage_Manager( void )
{
cImage_Manager::Delete_All();
}
void cImage_Manager :: Add( cGL_Surface *obj )
{
if( !obj )
{
return;
}
// it is now managed
obj->m_managed = 1;
// Add
cObject_Manager<cGL_Surface>::Add( obj );
}
cGL_Surface *cImage_Manager :: Get_Pointer( const std::string &path ) const
{
for( GL_Surface_List::const_iterator itr = objects.begin(), itr_end = objects.end(); itr != itr_end; ++itr )
{
cGL_Surface *obj = (*itr);
// return first match
if( obj->m_filename.compare( path ) == 0 )
{
return obj;
}
}
// not found
return NULL;
}
cGL_Surface *cImage_Manager :: Copy( const std::string &path )
{
for( GL_Surface_List::iterator itr = objects.begin(), itr_end = objects.end(); itr != itr_end; ++itr )
{
// get object
cGL_Surface *obj = (*itr);
// first match
if( obj->m_filename.compare( path ) == 0 )
{
return obj->Copy();
}
}
// not found
return NULL;
}
void cImage_Manager :: Grab_Textures( bool from_file /* = 0 */, bool draw_gui /* = 0 */ )
{
// progress bar
CEGUI::ProgressBar *progress_bar = NULL;
if( draw_gui )
{
// get progress bar
progress_bar = static_cast<CEGUI::ProgressBar *>(CEGUI::WindowManager::getSingleton().getWindow( "progress_bar" ));
progress_bar->setProgress( 0 );
// set loading screen text
Loading_Screen_Draw_Text( _("Saving Textures") );
}
unsigned int loaded_files = 0;
unsigned int file_count = objects.size();
// save all textures
for( GL_Surface_List::iterator itr = objects.begin(), itr_end = objects.end(); itr != itr_end; ++itr )
{
// get surface
cGL_Surface *obj = (*itr);
// skip surfaces with an already deleted texture
if( !glIsTexture( obj->m_image ) )
{
continue;
}
// get software texture and save it to software memory
saved_textures.push_back( obj->Get_Software_Texture( from_file ) );
// delete hardware texture
if( glIsTexture( obj->m_image ) )
{
glDeleteTextures( 1, &obj->m_image );
}
// count files
loaded_files++;
// draw
if( draw_gui )
{
// update progress
progress_bar->setProgress( static_cast<float>(loaded_files) / static_cast<float>(file_count) );
Loading_Screen_Draw();
}
}
}
void cImage_Manager :: Restore_Textures( bool draw_gui /* = 0 */ )
{
// progress bar
CEGUI::ProgressBar *progress_bar = NULL;
if( draw_gui )
{
// get progress bar
progress_bar = static_cast<CEGUI::ProgressBar *>(CEGUI::WindowManager::getSingleton().getWindow( "progress_bar" ));
progress_bar->setProgress( 0 );
// set loading screen text
Loading_Screen_Draw_Text( _("Restoring Textures") );
}
unsigned int loaded_files = 0;
unsigned int file_count = saved_textures.size();
// load back into hardware textures
for( Saved_Texture_List::iterator itr = saved_textures.begin(), itr_end = saved_textures.end(); itr != itr_end; ++itr )
{
// get saved texture
cSaved_Texture *soft_tex = (*itr);
// load it
soft_tex->base->Load_Software_Texture( soft_tex );
// delete
delete soft_tex;
// count files
loaded_files++;
// draw
if( draw_gui )
{
// update progress
progress_bar->setProgress( static_cast<float>(loaded_files) / static_cast<float>(file_count) );
Loading_Screen_Draw();
}
}
saved_textures.clear();
}
void cImage_Manager :: Delete_Image_Textures( void )
{
for( GL_Surface_List::iterator itr = objects.begin(), itr_end = objects.end(); itr != itr_end; ++itr )
{
// get object
cGL_Surface *obj = (*itr);
if( obj->m_auto_del_img && glIsTexture( obj->m_image ) )
{
glDeleteTextures( 1, &obj->m_image );
}
}
}
void cImage_Manager :: Delete_Hardware_Textures( void )
{
// delete all hardware surfaces
for( GLuint i = 0; i < high_texture_id; i++ )
{
if( glIsTexture( i ) )
{
printf( "ImageManager : deleting texture %d\n", i );
glDeleteTextures( 1, &i );
}
}
high_texture_id = 0;
}
void cImage_Manager :: Delete_All( void )
{
// stops cGL_Surface destructor from checking if GL texture id still in use
Delete_Image_Textures();
cObject_Manager<cGL_Surface>::Delete_All();
}
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
cImage_Manager *pImage_Manager = NULL;
/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
} // namespace SMC
| [
"[email protected]"
] | [
[
[
1,
247
]
]
] |
4fec6fd1c84ade18ccb712e4c51ad3fd3432b34b | 84eb4d8734cf167392a172de6212581c360cfcfb | /src/emulator/framebuffer.cpp | c40cca95002beb30bc7ddec1ec17fc8ea93536b7 | [
"BSD-3-Clause"
] | permissive | ps2homebrew/LuaPlayer | c374cbbcde539c038607df12b592c89c246f702e | da9be8b17fcd78bec8bdd002147bb4d7e8ba906f | refs/heads/master | 2020-06-19T18:38:02.423991 | 2006-11-28T07:11:32 | 2006-11-28T07:11:32 | 74,839,652 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 72 | cpp | #include <psptypes.h>
#include "../graphics.h"
Color* g_vram_base;
| [
"evilo@5c23000f-aefb-0310-8550-8024f1b2be0e"
] | [
[
[
1,
4
]
]
] |
f4ba3593a43e171e06d28f3dcbdde8b8f12abe23 | f7682efd1b53576a60beea5fe905d7cc9d21d5f4 | /money/money/money.cpp | de1be0bac405a1ad5cd70d85e9373fbf7c8d0eb6 | [] | no_license | douglasguo/eclipselu | 696c36526918258690438e2fe62b76e7230ecb13 | 19529f0ae778a5ccd2f92d57a27c83aebf845b9a | refs/heads/master | 2016-09-06T18:37:05.105486 | 2010-05-14T06:32:41 | 2010-05-14T06:32:41 | 39,516,656 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 812 | cpp | /*
ID: eclipse5
PROG: money
LANG: C++
*/
#include <cstdio>
#include <cstring>
int v,n;
int t[26]; //money system
long long f[10001];
bool used[10001];
//input may contain duplicate coin types
//so you may need to optimize init subroutine
void init()
{
int i,cnt,num;
memset(used,false,sizeof(used));
scanf("%d%d",&cnt,&n);
v=0;
for (i=0;i<cnt;i++)
{
scanf("%d",&num);
if (num<=n&&!used[num])
{
used[num]=true;
t[++v]=num;
}
}
memset(f,0,sizeof(f));
}
void dp() //two dimensional dp will get time limit exceeded
{
int i,j;
f[0]=1;
for (i=1;i<=v;i++)
for (j=t[i];j<=n;j++)
f[j]+=f[j-t[i]];
printf("%lld\n",f[n]);
}
int main()
{
freopen("money.in","r",stdin);
freopen("money.out","w",stdout);
init();
dp();
return 0;
} | [
"eclipselu@bf7c4ae8-0690-11df-8158-c7cbc0dd6240"
] | [
[
[
1,
52
]
]
] |
7ea858df73e2da426e0a0e2e3f47c21beba37b74 | 28e96305e2659b581a6a8002c795e52dd6fbd53c | /zFileOpener/main.cpp | 6a0deb6e04f2d88caa499b3771266a5e9dedf114 | [] | no_license | situr/open-magx-src | 970cd649903b223292d9274478d97f161ba52006 | 87bea580360c7fcf8270b642cc38b65252e6b1cc | refs/heads/master | 2020-12-25T09:47:07.262768 | 2011-11-16T03:37:49 | 2011-11-16T03:37:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,052 | cpp | //
// C++ Implementation: zFileOpener 0.2
//
// Description:
//
//
// Author: Ant-ON <[email protected]>, (C) 2010
//
//
#include <ZApplication.h>
#include <iostream>
#include <qstring.h>
#include <qstringlist.h>
#include <ZMessageDlg.h>
#include <ZSingleSelectDlg.h>
#include <ZProgressDlg.h>
ZApplication* app;
using namespace std;
#define LNG_PATH QString("/ezxlocal/download/mystuff/.system/lng/zFileOpener")
#define PATH_7Z "/usr/mbin/7z x %1 -o%2"
static ZConfig * cLng = 0;
QString getLangLine( QString sFrase )
{
if ( !cLng )
{
QString curLng;
ZConfig cfg( "/ezxlocal/download/appwrite/setup/ezx_system.cfg" );
curLng = cfg.readEntry(QString("SYS_SYSTEM_SET"), QString("LanguageType"), "");
if ( curLng.length() > 1 )
curLng = QString(curLng[0]) + QString(curLng[1]);
cLng = new ZConfig( LNG_PATH+"/"+curLng+".lng" );
}
return QString::fromUtf8(cLng->readEntry(QString("mes"), sFrase, sFrase).utf8()).replace("/n","\n");
}
int main ( int argc, char **argv )
{
app = new ZApplication ( argc, argv );
cout << "zFileOpener 0.2 by Ant-ON" << endl;
if ( argc > 1 )
{
QString sFile;
if (argc > 2)
sFile = argv[2];
else
sFile = argv[1];
QString sExt = sFile.right(4);
if ( sFile.right(3)==".sh" || sExt==".lin" )
{
ZMessageDlg * dlg = new ZMessageDlg();
dlg->setType(ZMessageDlg::TypeConfirm);
dlg->setMessage( getLangLine("runSh").arg( sFile.right( sFile.length()-sFile.findRev("/")-1 ) ) );
if ( dlg->exec() == QDialog::Accepted )
system( sFile+"&" );
delete dlg;
dlg=NULL;
} else
if ( sFile.right(3)==".7z" || sExt==".rar" || sExt==".zip" || sExt==".tgz" || sExt==".tar" || sExt==".bz2" || sExt==".rpm" || sFile.right(3)==".gz" || sFile.right(5)==".gtar" )
{
QString dir = sFile.left( sFile.findRev("/")+1 );
QString newDir = sFile.right( sFile.length()-sFile.findRev("/")-1 );
newDir = newDir.left( newDir.findRev(".") );
ZSingleSelectDlg * dlg = new ZSingleSelectDlg( "", getLangLine("extarctTo") );
QStringList list;
list.append( getLangLine("curDir") );
list.append( getLangLine("fileNameDir").arg(newDir) );
dlg->addItemsList( list );
if ( dlg->exec() == QDialog::Accepted )
{
ZProgressDlg* dlgProc = new ZProgressDlg("", getLangLine("mesExtract"), "" );
dlgProc->show();
qApp->processEvents();
qApp->processEvents();
switch ( dlg->getCheckedItemIndex() )
{
case 0:
system( QString(PATH_7Z).arg( sFile ).arg( dir ).utf8() );
break;
case 1:
system( QString( "mkdir -p %1" ).arg( dir+newDir ).utf8() );
qApp->processEvents();
system( QString(PATH_7Z).arg( sFile ).arg( dir+newDir ).utf8() );
break;
default:
break;
}
qApp->processEvents();
dlgProc->hide();
qApp->processEvents();
delete dlgProc;
}
delete dlg;
dlg=NULL;
}
}
cout << "Exit app" << endl;
delete app;
app = NULL;
return 1;
}
| [
"[email protected]"
] | [
[
[
1,
113
]
]
] |
a2287fa77866ab5f4f3e1604ab28f302c6d6b269 | 8ef9a757bf54e717e629009c91dd4975d650a5b6 | /src/light.h | b85778618ebcd0fda783db8283d1e49da81fe110 | [] | no_license | xorelvistor/gpuraytracer | d85fd7ec8c6352a55e7cf067b0a0f53819e4d40c | 8981c6f97bf5168301590ea4fe044d9b976ce4d1 | refs/heads/master | 2021-01-10T01:17:22.066301 | 2010-06-21T13:11:13 | 2010-06-21T13:11:13 | 48,695,838 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 80 | h | #pragma once
#ifndef LIGHT_H
#define LIGHT_H
class Light
{
};
#endif | [
"syberbyte@e4f89980-dd90-11de-b357-fb893c5a43fa"
] | [
[
[
1,
10
]
]
] |
0b27a9ecd2499b1e125d4500d61036b1dfe05e04 | c5534a6df16a89e0ae8f53bcd49a6417e8d44409 | /trunk/Dependencies/Xerces/include/xercesc/validators/common/DFAContentModel.cpp | c3dd40ab0caf4379cb35ed4807d2be8cc2c076f4 | [] | no_license | svn2github/ngene | b2cddacf7ec035aa681d5b8989feab3383dac012 | 61850134a354816161859fe86c2907c8e73dc113 | refs/heads/master | 2023-09-03T12:34:18.944872 | 2011-07-27T19:26:04 | 2011-07-27T19:26:04 | 78,163,390 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 47,061 | cpp | /*
* Copyright 1999-2001,2004 The Apache Software Foundation.
*
* 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.
*/
/*
* $Id: DFAContentModel.cpp 191054 2005-06-17 02:56:35Z jberry $
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/RuntimeException.hpp>
#include <xercesc/framework/XMLBuffer.hpp>
#include <xercesc/framework/XMLElementDecl.hpp>
#include <xercesc/framework/XMLValidator.hpp>
#include <xercesc/validators/common/CMAny.hpp>
#include <xercesc/validators/common/CMBinaryOp.hpp>
#include <xercesc/validators/common/CMLeaf.hpp>
#include <xercesc/validators/common/CMUnaryOp.hpp>
#include <xercesc/validators/common/DFAContentModel.hpp>
#include <xercesc/validators/common/ContentSpecNode.hpp>
#include <xercesc/validators/common/Grammar.hpp>
#include <xercesc/validators/schema/SchemaSymbols.hpp>
#include <xercesc/validators/schema/SubstitutionGroupComparator.hpp>
#include <xercesc/validators/schema/XercesElementWildcard.hpp>
#include <xercesc/util/RefHashTableOf.hpp>
#include <xercesc/util/HashCMStateSet.hpp>
#include <xercesc/util/XMLInteger.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// DFAContentModel: Constructors and Destructor
// ---------------------------------------------------------------------------
DFAContentModel::DFAContentModel( const bool dtd
, ContentSpecNode* const elemContentSpec
, MemoryManager* const manager) :
fElemMap(0)
, fElemMapType(0)
, fElemMapSize(0)
, fEmptyOk(false)
, fEOCPos(0)
, fFinalStateFlags(0)
, fFollowList(0)
, fHeadNode(0)
, fLeafCount(0)
, fLeafList(0)
, fLeafListType(0)
, fTransTable(0)
, fTransTableSize(0)
, fDTD(dtd)
, fIsMixed(false)
, fLeafNameTypeVector(0)
, fMemoryManager(manager)
{
// And build the DFA data structures
buildDFA(elemContentSpec);
}
DFAContentModel::DFAContentModel( const bool dtd
, ContentSpecNode* const elemContentSpec
, const bool isMixed
, MemoryManager* const manager):
fElemMap(0)
, fElemMapType(0)
, fElemMapSize(0)
, fEmptyOk(false)
, fEOCPos(0)
, fFinalStateFlags(0)
, fFollowList(0)
, fHeadNode(0)
, fLeafCount(0)
, fLeafList(0)
, fLeafListType(0)
, fTransTable(0)
, fTransTableSize(0)
, fDTD(dtd)
, fIsMixed(isMixed)
, fLeafNameTypeVector(0)
, fMemoryManager(manager)
{
// And build the DFA data structures
buildDFA(elemContentSpec);
}
DFAContentModel::~DFAContentModel()
{
//
// Clean up all the stuff that is not just temporary representation
// data that was cleaned up after building the DFA.
//
fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
unsigned index;
for (index = 0; index < fTransTableSize; index++)
fMemoryManager->deallocate(fTransTable[index]); //delete [] fTransTable[index];
fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
for (index = 0; index < fLeafCount; index++)
delete fElemMap[index];
fMemoryManager->deallocate(fElemMap); //delete [] fElemMap;
fMemoryManager->deallocate(fElemMapType); //delete [] fElemMapType;
fMemoryManager->deallocate(fLeafListType); //delete [] fLeafListType;
delete fLeafNameTypeVector;
}
// ---------------------------------------------------------------------------
// DFAContentModel: Implementation of the ContentModel virtual interface
// ---------------------------------------------------------------------------
int
DFAContentModel::validateContent( QName** const children
, const unsigned int childCount
, const unsigned int) const
{
//
// If there are no children, then either we fail on the 0th element
// or we return success. It depends upon whether this content model
// accepts empty content, which we determined earlier.
//
if (!childCount)
{
// success -1
return fEmptyOk ? -1 : 0;
}
//
// Lets loop through the children in the array and move our way
// through the states. Note that we use the fElemMap array to map
// an element index to a state index.
//
unsigned int curState = 0;
unsigned int nextState = 0;
unsigned int childIndex = 0;
for (; childIndex < childCount; childIndex++)
{
// Get the current element index out
const QName* curElem = children[childIndex];
const XMLCh* curElemRawName = 0;
if (fDTD)
curElemRawName = curElem->getRawName();
// If this is text in a Schema mixed content model, skip it.
if ( fIsMixed &&
( curElem->getURI() == XMLElementDecl::fgPCDataElemId))
continue;
// Look up this child in our element map
unsigned int elemIndex = 0;
for (; elemIndex < fElemMapSize; elemIndex++)
{
const QName* inElem = fElemMap[elemIndex];
if (fDTD) {
if (XMLString::equals(inElem->getRawName(), curElemRawName)) {
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
else {
ContentSpecNode::NodeTypes type = fElemMapType[elemIndex];
if (type == ContentSpecNode::Leaf)
{
if ((inElem->getURI() == curElem->getURI()) &&
(XMLString::equals(inElem->getLocalPart(), curElem->getLocalPart()))) {
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
else if ((type & 0x0f)== ContentSpecNode::Any)
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
else if ((type & 0x0f) == ContentSpecNode::Any_NS)
{
if (inElem->getURI() == curElem->getURI())
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
else if ((type & 0x0f) == ContentSpecNode::Any_Other)
{
if (inElem->getURI() != curElem->getURI()) {
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
}
}//for elemIndex
// If "nextState" is -1, we found a match, but the transition is invalid
if (nextState == XMLContentModel::gInvalidTrans)
return childIndex;
// If we didn't find it, then obviously not valid
if (elemIndex == fElemMapSize)
return childIndex;
curState = nextState;
nextState = 0;
}//for childIndex
//
// We transitioned all the way through the input list. However, that
// does not mean that we ended in a final state. So check whether
// our ending state is a final state.
//
if (!fFinalStateFlags[curState])
return childIndex;
//success
return -1;
}
int DFAContentModel::validateContentSpecial(QName** const children
, const unsigned int childCount
, const unsigned int
, GrammarResolver* const pGrammarResolver
, XMLStringPool* const pStringPool) const
{
SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
if (childCount == 0)
return fEmptyOk ? -1 : 0;
//
// Lets loop through the children in the array and move our way
// through the states. Note that we use the fElemMap array to map
// an element index to a state index.
//
unsigned int curState = 0;
unsigned int nextState = 0;
unsigned int childIndex = 0;
for (; childIndex < childCount; childIndex++)
{
// Get the current element index out
QName* curElem = children[childIndex];
// If this is text in a Schema mixed content model, skip it.
if ( fIsMixed &&
( curElem->getURI() == XMLElementDecl::fgPCDataElemId))
continue;
// Look up this child in our element map
unsigned int elemIndex = 0;
for (; elemIndex < fElemMapSize; elemIndex++)
{
QName* inElem = fElemMap[elemIndex];
ContentSpecNode::NodeTypes type = fElemMapType[elemIndex];
if (type == ContentSpecNode::Leaf)
{
if (comparator.isEquivalentTo(curElem, inElem) )
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
else if ((type & 0x0f)== ContentSpecNode::Any)
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
else if ((type & 0x0f) == ContentSpecNode::Any_NS)
{
if (inElem->getURI() == curElem->getURI())
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
else if ((type & 0x0f) == ContentSpecNode::Any_Other)
{
if (inElem->getURI() != curElem->getURI())
{
nextState = fTransTable[curState][elemIndex];
if (nextState != XMLContentModel::gInvalidTrans)
break;
}
}
}//for elemIndex
// If "nextState" is -1, we found a match, but the transition is invalid
if (nextState == XMLContentModel::gInvalidTrans)
return childIndex;
// If we didn't find it, then obviously not valid
if (elemIndex == fElemMapSize)
return childIndex;
curState = nextState;
nextState = 0;
}//for childIndex
//
// We transitioned all the way through the input list. However, that
// does not mean that we ended in a final state. So check whether
// our ending state is a final state.
//
if (!fFinalStateFlags[curState])
return childIndex;
//success
return -1;
}
// ---------------------------------------------------------------------------
// DFAContentModel: Private helper methods
// ---------------------------------------------------------------------------
void DFAContentModel::buildDFA(ContentSpecNode* const curNode)
{
unsigned int index;
//
// The first step we need to take is to rewrite the content model using
// our CMNode objects, and in the process get rid of any repetition short
// cuts, converting them into '*' style repetitions or getting rid of
// repetitions altogether.
//
// The conversions done are:
//
// x+ -> (x|x*)
// x? -> (x|epsilon)
//
// This is a relatively complex scenario. What is happening is that we
// create a top level binary node of which the special EOC value is set
// as the right side node. The the left side is set to the rewritten
// syntax tree. The source is the original content model info from the
// decl pool. The rewrite is done by buildSyntaxTree() which recurses the
// decl pool's content of the element and builds a new tree in the
// process.
//
// Note that, during this operation, we set each non-epsilon leaf node's
// DFA state position and count the number of such leafs, which is left
// in the fLeafCount member.
//
CMLeaf* nodeEOC = new (fMemoryManager) CMLeaf
(
new (fMemoryManager) QName
(
XMLUni::fgZeroLenString
, XMLUni::fgZeroLenString
, XMLContentModel::gEOCFakeId
, fMemoryManager
)
, ~0
, true
, fMemoryManager
);
CMNode* nodeOrgContent = buildSyntaxTree(curNode);
fHeadNode = new (fMemoryManager) CMBinaryOp
(
ContentSpecNode::Sequence
, nodeOrgContent
, nodeEOC
, fMemoryManager
);
//
// And handle specially the EOC node, which also must be numbered and
// counted as a non-epsilon leaf node. It could not be handled in the
// above tree build because it was created before all that started. We
// save the EOC position since its used during the DFA building loop.
//
fEOCPos = fLeafCount;
nodeEOC->setPosition(fLeafCount++);
//
// Ok, so now we have to iterate the new tree and do a little more work
// now that we know the leaf count. One thing we need to do is to
// calculate the first and last position sets of each node. This is
// cached away in each of the nodes.
//
// Along the way we also set the leaf count in each node as the maximum
// state count. They must know this in order to create their first/last
// position sets.
//
// We also need to build an array of references to the non-epsilon
// leaf nodes. Since we iterate here the same way as we did during the
// initial tree build (which built their position numbers, we will put
// them in the array according to their position values.
//
fLeafList = (CMLeaf**) fMemoryManager->allocate(fLeafCount*sizeof(CMLeaf*)); //new CMLeaf*[fLeafCount];
fLeafListType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
(
fLeafCount * sizeof(ContentSpecNode::NodeTypes)
); //new ContentSpecNode::NodeTypes[fLeafCount];
postTreeBuildInit(fHeadNode, 0);
//
// And, moving onward... We now need to build the follow position sets
// for all the nodes. So we allocate an array of pointers to state sets,
// one for each leaf node (i.e. each significant DFA position.)
//
fFollowList = (CMStateSet**) fMemoryManager->allocate
(
fLeafCount * sizeof(CMStateSet*)
); //new CMStateSet*[fLeafCount];
for (index = 0; index < fLeafCount; index++)
fFollowList[index] = new (fMemoryManager) CMStateSet(fLeafCount, fMemoryManager);
calcFollowList(fHeadNode);
//
// Check to see whether this content model can handle an empty content,
// which is something we need to optimize by looking now before we
// throw away the info that would tell us that.
//
// If the left node of the head (the top level of the original content)
// is nullable, then its true.
//
fEmptyOk = nodeOrgContent->isNullable();
//
// And finally the big push... Now we build the DFA using all the states
// and the tree we've built up. First we set up the various data
// structures we are going to use while we do this.
//
// First of all we need an array of unique element ids in our content
// model. For each transition table entry, we need a set of contiguous
// indices to represent the transitions for a particular input element.
// So we need to a zero based range of indexes that map to element types.
// This element map provides that mapping.
//
fElemMap = (QName**) fMemoryManager->allocate
(
fLeafCount * sizeof(QName*)
); //new QName*[fLeafCount];
fElemMapType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
(
fLeafCount * sizeof(ContentSpecNode::NodeTypes)
); //new ContentSpecNode::NodeTypes[fLeafCount];
fElemMapSize = 0;
for (unsigned int outIndex = 0; outIndex < fLeafCount; outIndex++)
{
fElemMap[outIndex] = new (fMemoryManager) QName(fMemoryManager);
if ( (fLeafListType[outIndex] & 0x0f) != ContentSpecNode::Leaf )
if (!fLeafNameTypeVector)
fLeafNameTypeVector = new (fMemoryManager) ContentLeafNameTypeVector(fMemoryManager);
// Get the current leaf's element index
const QName* element = fLeafList[outIndex]->getElement();
const XMLCh* elementRawName = 0;
if (fDTD && element)
elementRawName = element->getRawName();
// See if the current leaf node's element index is in the list
unsigned int inIndex = 0;
for (; inIndex < fElemMapSize; inIndex++)
{
const QName* inElem = fElemMap[inIndex];
if (fDTD) {
if (XMLString::equals(inElem->getRawName(), elementRawName)) {
break;
}
}
else {
if ((fElemMapType[inIndex] == fLeafListType[outIndex]) &&
(inElem->getURI() == element->getURI()) &&
(XMLString::equals(inElem->getLocalPart(), element->getLocalPart()))) {
break;
}
}
}
// If it was not in the list, then add it and bump the map size
if (inIndex == fElemMapSize)
{
fElemMap[fElemMapSize]->setValues(*element);
fElemMapType[fElemMapSize] = fLeafListType[outIndex];
++fElemMapSize;
}
}
// set up the fLeafNameTypeVector object if there is one.
if (fLeafNameTypeVector) {
fLeafNameTypeVector->setValues(fElemMap, fElemMapType, fElemMapSize);
}
/***
* Optimization(Jan, 2001); We sort fLeafList according to
* elemIndex which is *uniquely* associated to each leaf.
* We are *assuming* that each element appears in at least one leaf.
**/
// don't forget to delete it
int *fLeafSorter = (int*) fMemoryManager->allocate
(
(fLeafCount + fElemMapSize) * sizeof(int)
); //new int[fLeafCount + fElemMapSize];
unsigned int fSortCount = 0;
for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
{
const QName* element = fElemMap[elemIndex];
const XMLCh* elementRawName = 0;
if (fDTD && element)
elementRawName = element->getRawName();
for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
{
const QName* leaf = fLeafList[leafIndex]->getElement();
if (fDTD) {
if (XMLString::equals(leaf->getRawName(), elementRawName)) {
fLeafSorter[fSortCount++] = leafIndex;
}
}
else {
if ((fElemMapType[elemIndex] == fLeafListType[leafIndex]) &&
(leaf->getURI() == element->getURI()) &&
(XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
fLeafSorter[fSortCount++] = leafIndex;
}
}
}
fLeafSorter[fSortCount++] = -1;
}
//
// Next lets create some arrays, some that that hold transient info
// during the DFA build and some that are permament. These are kind of
// sticky since we cannot know how big they will get, but we don't want
// to use any collection type classes because of performance.
//
// Basically they will probably be about fLeafCount*2 on average, but can
// be as large as 2^(fLeafCount*2), worst case. So we start with
// fLeafCount*4 as a middle ground. This will be very unlikely to ever
// have to expand though, it if does, the overhead will be somewhat ugly.
//
unsigned int curArraySize = fLeafCount * 4;
const CMStateSet** statesToDo = (const CMStateSet**)
fMemoryManager->allocate
(
curArraySize * sizeof(const CMStateSet*)
); //new const CMStateSet*[curArraySize];
fFinalStateFlags = (bool*) fMemoryManager->allocate
(
curArraySize * sizeof(bool)
); //new bool[curArraySize];
fTransTable = (unsigned int**) fMemoryManager->allocate
(
curArraySize * sizeof(unsigned int*)
); //new unsigned int*[curArraySize];
//
// Ok we start with the initial set as the first pos set of the head node
// (which is the seq node that holds the content model and the EOC node.)
//
const CMStateSet* setT = new (fMemoryManager) CMStateSet(fHeadNode->getFirstPos());
//
// Init our two state flags. Basically the unmarked state counter is
// always chasing the current state counter. When it catches up, that
// means we made a pass through that did not add any new states to the
// lists, at which time we are done. We could have used a expanding array
// of flags which we used to mark off states as we complete them, but
// this is easier though less readable maybe.
//
unsigned int unmarkedState = 0;
unsigned int curState = 0;
//
// Init the first transition table entry, and put the initial state
// into the states to do list, then bump the current state.
//
fTransTable[curState] = makeDefStateList();
statesToDo[curState] = setT;
curState++;
//
// the stateTable is an auxiliary means to fast
// identification of new state created (instead
// of squential loop statesToDo to find out),
// while the role that statesToDo plays remain unchanged.
//
// TODO: in the future, we may change the 29 to something
// derived from curArraySize.
RefHashTableOf<XMLInteger> *stateTable =
new (fMemoryManager) RefHashTableOf<XMLInteger>
(
curArraySize
, true
, new (fMemoryManager) HashCMStateSet()
, fMemoryManager
);
//stateTable->put((CMStateSet*)setT, new (fMemoryManager) XMLInteger(0));
//
// Ok, almost done with the algorithm from hell... We now enter the
// loop where we go until the states done counter catches up with
// the states to do counter.
//
CMStateSet* newSet = 0;
while (unmarkedState < curState)
{
//
// Get the next unmarked state out of the list of states to do.
// And get the associated transition table entry.
//
setT = statesToDo[unmarkedState];
unsigned int* transEntry = fTransTable[unmarkedState];
// Mark this one final if it contains the EOC state
fFinalStateFlags[unmarkedState] = setT->getBit(fEOCPos);
// Bump up the unmarked state count, marking this state done
unmarkedState++;
// Optimization(Jan, 2001)
unsigned int sorterIndex = 0;
// Optimization(Jan, 2001)
// Loop through each possible input symbol in the element map
for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
{
//
// Build up a set of states which is the union of all of the
// follow sets of DFA positions that are in the current state. If
// we gave away the new set last time through then create a new
// one. Otherwise, zero out the existing one.
//
if (!newSet)
newSet = new (fMemoryManager) CMStateSet
(
fLeafCount
, fMemoryManager
);
else
newSet->zeroBits();
#ifdef OBSOLETED
// unoptimized code
for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
{
// If this leaf index (DFA position) is in the current set...
if (setT->getBit(leafIndex))
{
//
// If this leaf is the current input symbol, then we want
// to add its follow list to the set of states to transition
// to from the current state.
//
const QName* leaf = fLeafList[leafIndex]->getElement();
const QName* element = fElemMap[elemIndex];
if (fDTD) {
if (XMLString::equals(leaf->getRawName(), element->getRawName())) {
*newSet |= *fFollowList[leafIndex];
}
}
else {
if ((leaf->getURI() == element->getURI()) &&
(XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
*newSet |= *fFollowList[leafIndex];
}
}
}
} // for leafIndex
#endif
// Optimization(Jan, 2001)
int leafIndex = fLeafSorter[sorterIndex++];
while (leafIndex != -1)
{
// If this leaf index (DFA position) is in the current set...
if (setT->getBit(leafIndex))
{
//
// If this leaf is the current input symbol, then we
// want to add its follow list to the set of states to
// transition to from the current state.
//
*newSet |= *fFollowList[leafIndex];
}
leafIndex = fLeafSorter[sorterIndex++];
} // while (leafIndex != -1)
//
// If this new set is not empty, then see if its in the list
// of states to do. If not, then add it.
//
if (!newSet->isEmpty())
{
//
// Search the 'states to do' list to see if this new
// state set is already in there.
//
/***
unsigned int stateIndex = 0;
for (; stateIndex < curState; stateIndex++)
{
if (*statesToDo[stateIndex] == *newSet)
break;
}
***/
XMLInteger *stateObj = (XMLInteger*) (stateTable->get(newSet));
unsigned int stateIndex = (stateObj == 0 ? curState : stateObj->intValue());
// If we did not find it, then add it
if (stateIndex == curState)
{
//
// Put this new state into the states to do and init
// a new entry at the same index in the transition
// table.
//
statesToDo[curState] = newSet;
fTransTable[curState] = makeDefStateList();
stateTable->put
(
newSet
, new (fMemoryManager) XMLInteger(curState)
);
// We now have a new state to do so bump the count
curState++;
//
// Null out the new set to indicate we adopted it. This
// will cause the creation of a new set on the next time
// around the loop.
//
newSet = 0;
}
//
// Now set this state in the transition table's entry for this
// element (using its index), with the DFA state we will move
// to from the current state when we see this input element.
//
transEntry[elemIndex] = stateIndex;
// Expand the arrays if we're full
if (curState == curArraySize)
{
//
// Yikes, we overflowed the initial array size, so we've
// got to expand all of these arrays. So adjust up the
// size by 50% and allocate new arrays.
//
const unsigned int newSize = (unsigned int)(curArraySize * 1.5);
const CMStateSet** newToDo = (const CMStateSet**)
fMemoryManager->allocate
(
newSize * sizeof(const CMStateSet*)
); //new const CMStateSet*[newSize];
bool* newFinalFlags = (bool*) fMemoryManager->allocate
(
newSize * sizeof(bool)
); //new bool[newSize];
unsigned int** newTransTable = (unsigned int**)
fMemoryManager->allocate
(
newSize * sizeof(unsigned int*)
); //new unsigned int*[newSize];
// Copy over all of the existing content
for (unsigned int expIndex = 0; expIndex < curArraySize; expIndex++)
{
newToDo[expIndex] = statesToDo[expIndex];
newFinalFlags[expIndex] = fFinalStateFlags[expIndex];
newTransTable[expIndex] = fTransTable[expIndex];
}
// Clean up the old stuff
fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
// Store the new array size and pointers
curArraySize = newSize;
statesToDo = newToDo;
fFinalStateFlags = newFinalFlags;
fTransTable = newTransTable;
} //if (curState == curArraySize)
} //if (!newSet->isEmpty())
} // for elemIndex
} //while
// Store the current state count in the trans table size
fTransTableSize = curState;
// If the last temp set was not stored, then clean it up
if (newSet)
delete newSet;
//
// Now we can clean up all of the temporary data that was needed during
// DFA build.
//
//
// Note on memory leak: Bugzilla#2707:
// ===================================
// The CMBinary, pointed to by fHeadNode, shall be released by
// deleted by itself.
//
// Change has been made to postTreeBuildInit() such that fLeafList[]
// would maintain its **OWN** copy of CMLeaf to avoid double deletion
// of CMLeaf.
//
delete fHeadNode;
for (index = 0; index < fLeafCount; index++)
delete fFollowList[index];
fMemoryManager->deallocate(fFollowList); //delete [] fFollowList;
//
// removeAll() will delete all data, XMLInteger,
// while the keys are to be deleted by the
// deletion of statesToDo.
//
delete stateTable;
for (index = 0; index < curState; index++)
delete (CMStateSet*)statesToDo[index];
fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
for (index = 0; index < fLeafCount; index++)
delete fLeafList[index];
fMemoryManager->deallocate(fLeafList); //delete [] fLeafList;
fMemoryManager->deallocate(fLeafSorter); //delete [] fLeafSorter;
}
CMNode* DFAContentModel::buildSyntaxTree(ContentSpecNode* const curNode)
{
// Initialize a return node pointer
CMNode* retNode = 0;
// Get the spec type of the passed node
const ContentSpecNode::NodeTypes curType = curNode->getType();
if ((curType & 0x0f) == ContentSpecNode::Any
|| (curType & 0x0f) == ContentSpecNode::Any_Other
|| (curType & 0x0f) == ContentSpecNode::Any_NS)
{
retNode = new (fMemoryManager) CMAny
(
curType
, curNode->getElement()->getURI()
, fLeafCount++
, fMemoryManager
);
}
else if (curType == ContentSpecNode::Leaf)
{
//
// Create a new leaf node, and pass it the current leaf count, which
// is its DFA state position. Bump the leaf count after storing it.
// This makes the positions zero based since we store first and then
// increment.
//
retNode = new (fMemoryManager) CMLeaf
(
curNode->getElement()
, fLeafCount++
, fMemoryManager
);
}
else
{
//
// Its not a leaf, so we have to recurse its left and maybe right
// nodes. Save both values before we recurse and trash the node.
//
ContentSpecNode* leftNode = curNode->getFirst();
ContentSpecNode* rightNode = curNode->getSecond();
if (((curType & 0x0f) == ContentSpecNode::Choice)
|| ((curType & 0x0f) == ContentSpecNode::Sequence))
{
//
// Recurse on both children, and return a binary op node with the
// two created sub nodes as its children. The node type is the
// same type as the source.
//
CMNode* newLeft = buildSyntaxTree(leftNode);
CMNode* newRight = buildSyntaxTree(rightNode);
retNode = new (fMemoryManager) CMBinaryOp
(
curType
, newLeft
, newRight
, fMemoryManager
);
}
else if (curType == ContentSpecNode::ZeroOrMore
|| curType == ContentSpecNode::ZeroOrOne
|| curType == ContentSpecNode::OneOrMore)
{
// This one is fine as is, just change to our form
retNode = new (fMemoryManager) CMUnaryOp
(
curType
, buildSyntaxTree(leftNode)
, fMemoryManager
);
}
else
{
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
}
}
return retNode;
}
void DFAContentModel::calcFollowList(CMNode* const curNode)
{
// Get the spec type of the passed node
const ContentSpecNode::NodeTypes curType = curNode->getType();
if ((curType & 0x0f) == ContentSpecNode::Choice)
{
// Just recurse
calcFollowList(((CMBinaryOp*)curNode)->getLeft());
calcFollowList(((CMBinaryOp*)curNode)->getRight());
}
else if ((curType & 0x0f) == ContentSpecNode::Sequence)
{
// Recurse before we process this node
calcFollowList(((CMBinaryOp*)curNode)->getLeft());
calcFollowList(((CMBinaryOp*)curNode)->getRight());
//
// Now handle our level. We use our left child's last pos set and our
// right child's first pos set, so get them now for convenience.
//
const CMStateSet& last = ((CMBinaryOp*)curNode)->getLeft()->getLastPos();
const CMStateSet& first = ((CMBinaryOp*)curNode)->getRight()->getFirstPos();
//
// Now, for every position which is in our left child's last set
// add all of the states in our right child's first set to the
// follow set for that position.
//
for (unsigned int index = 0; index < fLeafCount; index++)
{
if (last.getBit(index))
*fFollowList[index] |= first;
}
}
else if (curType == ContentSpecNode::ZeroOrMore ||
curType == ContentSpecNode::OneOrMore )
{
// Recurse first
calcFollowList(((CMUnaryOp*)curNode)->getChild());
//
// Now handle our level. We use our own first and last position
// sets, so get them up front.
//
const CMStateSet& first = curNode->getFirstPos();
const CMStateSet& last = curNode->getLastPos();
//
// For every position which is in our last position set, add all
// of our first position states to the follow set for that
// position.
//
for (unsigned int index = 0; index < fLeafCount; index++)
{
if (last.getBit(index))
*fFollowList[index] |= first;
}
}
else if (curType == ContentSpecNode::ZeroOrOne)
{
// Recurse only
calcFollowList(((CMUnaryOp*)curNode)->getChild());
}
}
//
// gInvalidTrans is used to represent bad transitions in the transition table
// entry for each state. So each entry is initialized to that value. This
// method creates a new entry and initializes it.
//
unsigned int* DFAContentModel::makeDefStateList() const
{
unsigned int* retArray = (unsigned int*) fMemoryManager->allocate
(
fElemMapSize * sizeof(unsigned int)
); //new unsigned int[fElemMapSize];
for (unsigned int index = 0; index < fElemMapSize; index++)
retArray[index] = XMLContentModel::gInvalidTrans;
return retArray;
}
int DFAContentModel::postTreeBuildInit( CMNode* const nodeCur
, const unsigned int curIndex)
{
// Set the maximum states on this node
nodeCur->setMaxStates(fLeafCount);
// Get the spec type of the passed node
const ContentSpecNode::NodeTypes curType = nodeCur->getType();
// Get a copy of the index we can modify
unsigned int newIndex = curIndex;
// Recurse as required
if ( ((curType & 0x0f) == ContentSpecNode::Any) ||
((curType & 0x0f) == ContentSpecNode::Any_NS) ||
((curType & 0x0f) == ContentSpecNode::Any_Other) )
{
fLeafList[newIndex] = new (fMemoryManager) CMLeaf
(
new (fMemoryManager) QName
(
XMLUni::fgZeroLenString
, XMLUni::fgZeroLenString
, ((CMAny*) nodeCur)->getURI()
, fMemoryManager
)
, ((CMAny*)nodeCur)->getPosition()
, true
, fMemoryManager
);
fLeafListType[newIndex] = curType;
++newIndex;
}
else if (((curType & 0x0f) == ContentSpecNode::Choice)
|| ((curType & 0x0f) == ContentSpecNode::Sequence))
{
newIndex = postTreeBuildInit(((CMBinaryOp*)nodeCur)->getLeft(), newIndex);
newIndex = postTreeBuildInit(((CMBinaryOp*)nodeCur)->getRight(), newIndex);
}
else if (curType == ContentSpecNode::ZeroOrMore ||
curType == ContentSpecNode::ZeroOrOne ||
curType == ContentSpecNode::OneOrMore)
{
newIndex = postTreeBuildInit(((CMUnaryOp*)nodeCur)->getChild(), newIndex);
}
else if (curType == ContentSpecNode::Leaf)
{
//
// Put this node in the leaf list at the current index if its
// a non-epsilon leaf.
//
if (((CMLeaf*)nodeCur)->getElement()->getURI() != XMLContentModel::gEpsilonFakeId)
{
//
// fLeafList make its own copy of the CMLeaf, so that
// delete[] fLeafList and delete the owner of the nodeCur
// will NOT delete the nodeCur --twice--,
// thuse to make delete the owner of the nodeCur possible.
//
fLeafList[newIndex] = new (fMemoryManager) CMLeaf
(
((CMLeaf*)nodeCur)->getElement()
, ((CMLeaf*)nodeCur)->getPosition()
, fMemoryManager
);
fLeafListType[newIndex] = ContentSpecNode::Leaf;
++newIndex;
}
}
else
{
ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
}
return newIndex;
}
ContentLeafNameTypeVector* DFAContentModel::getContentLeafNameTypeVector() const
{
//later change it to return the data member
return fLeafNameTypeVector;
}
void DFAContentModel::checkUniqueParticleAttribution (SchemaGrammar* const pGrammar,
GrammarResolver* const pGrammarResolver,
XMLStringPool* const pStringPool,
XMLValidator* const pValidator,
unsigned int* const pContentSpecOrgURI,
const XMLCh* pComplexTypeName /*= 0*/)
{
SubstitutionGroupComparator comparator(pGrammarResolver, pStringPool);
unsigned int i, j, k;
// Rename the URI back
for (i = 0; i < fElemMapSize; i++) {
unsigned int orgURIIndex = fElemMap[i]->getURI();
if ((orgURIIndex != XMLContentModel::gEOCFakeId) &&
(orgURIIndex != XMLContentModel::gEpsilonFakeId) &&
(orgURIIndex != XMLElementDecl::fgInvalidElemId) &&
(orgURIIndex != XMLElementDecl::fgPCDataElemId)) {
fElemMap[i]->setURI(pContentSpecOrgURI[orgURIIndex]);
}
}
// Unique Particle Attribution
// store the conflict results between any two elements in fElemMap
// XMLContentModel::gInvalidTrans: not compared; 0: no conflict; 1: conflict
unsigned int** fConflictTable = (unsigned int**) fMemoryManager->allocate
(
fElemMapSize * sizeof(unsigned int*)
); //new unsigned int*[fElemMapSize];
// initialize the conflict table
for (j = 0; j < fElemMapSize; j++) {
fConflictTable[j] = (unsigned int*) fMemoryManager->allocate
(
fElemMapSize * sizeof(unsigned int)
); //new unsigned int[fElemMapSize];
for (k = j+1; k < fElemMapSize; k++)
fConflictTable[j][k] = XMLContentModel::gInvalidTrans;
}
// for each state, check whether it has overlap transitions
for (i = 0; i < fTransTableSize; i++) {
for (j = 0; j < fElemMapSize; j++) {
for (k = j+1; k < fElemMapSize; k++) {
if (fTransTable[i][j] != XMLContentModel::gInvalidTrans &&
fTransTable[i][k] != XMLContentModel::gInvalidTrans &&
fConflictTable[j][k] == XMLContentModel::gInvalidTrans) {
// If this is text in a Schema mixed content model, skip it.
if ( fIsMixed &&
(( fElemMap[j]->getURI() == XMLElementDecl::fgPCDataElemId) ||
( fElemMap[k]->getURI() == XMLElementDecl::fgPCDataElemId)))
continue;
if (XercesElementWildcard::conflict(pGrammar,
fElemMapType[j],
fElemMap[j],
fElemMapType[k],
fElemMap[k],
&comparator)) {
fConflictTable[j][k] = 1;
XMLBuffer buf1(1023, fMemoryManager);
if (((fElemMapType[j] & 0x0f) == ContentSpecNode::Any) ||
((fElemMapType[j] & 0x0f) == ContentSpecNode::Any_NS))
buf1.set(SchemaSymbols::fgATTVAL_TWOPOUNDANY);
else if ((fElemMapType[j] & 0x0f) == ContentSpecNode::Any_Other)
buf1.set(SchemaSymbols::fgATTVAL_TWOPOUNDOTHER);
else
buf1.set(fElemMap[j]->getRawName());
XMLBuffer buf2(1023, fMemoryManager);
if (((fElemMapType[k] & 0x0f) == ContentSpecNode::Any) ||
((fElemMapType[k] & 0x0f) == ContentSpecNode::Any_NS))
buf2.set(SchemaSymbols::fgATTVAL_TWOPOUNDANY);
else if ((fElemMapType[k] & 0x0f) == ContentSpecNode::Any_Other)
buf2.set(SchemaSymbols::fgATTVAL_TWOPOUNDOTHER);
else
buf2.set(fElemMap[k]->getRawName());
pValidator->emitError(XMLValid::UniqueParticleAttributionFail,
pComplexTypeName,
buf1.getRawBuffer(),
buf2.getRawBuffer());
}
else
fConflictTable[j][k] = 0;
}
}
}
}
for (i = 0; i < fElemMapSize; i++)
fMemoryManager->deallocate(fConflictTable[i]); //delete [] fConflictTable[i];
fMemoryManager->deallocate(fConflictTable); //delete [] fConflictTable;
}
XERCES_CPP_NAMESPACE_END
| [
"Riddlemaster@fdc6060e-f348-4335-9a41-9933a8eecd57"
] | [
[
[
1,
1217
]
]
] |
f0be5ab1439a38fa78fea1a667d86875bfa7aece | aefc3d630a28e054a438d13ab16d32f2d39ccb1e | /XStrHelper.cpp | adfafacc7286715b2d8f53c44ded52e8c8e217f2 | [] | no_license | imcooder/publicwince | e64305d86496b550116c312d2e9a67e7fb33c6f8 | 58a337768161e1a10664b4d5edc2aadfb2ab1328 | refs/heads/master | 2021-05-28T10:40:35.786601 | 2010-06-27T06:25:09 | 2010-06-27T06:25:09 | 32,301,144 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 14,401 | cpp | /********************************************************************
Copyright (c) 2002-2003 汉王科技有限公司. 版权所有.
文件名称: XStrHelper.cpp
文件内容:
版本历史: 1.0
作者: xuejuntao [email protected] 2008/06/21
*********************************************************************/
#include "stdafx.h"
#include "XStrHelper.h"
#include <crtdefs.h>
#include <wchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void WINAPI Helper_StrChrChrA(LPSTR strString, const CHAR& A, const CHAR& B)
{
if (!strString)
{
return;
}
while (*strString)
{
if (A == *strString)
{
*strString = B;
}
strString ++;
}
}
void WINAPI Helper_StrChrChrW(LPWSTR strString, const WCHAR& A, const WCHAR& B)
{
if (!strString)
{
return;
}
while (*strString)
{
if (A == *strString)
{
*strString = B;
}
strString ++;
}
}
LPSTR WINAPI Helper_WCharToChar(LPCWSTR pwszStr)
{
CHAR *pchString = NULL;
if (pwszStr)
{
LONG nLen = (LONG)wcslen(pwszStr);
if (nLen > 0)
{
LONG nNeedLen = WideCharToMultiByte(CP_ACP, 0, pwszStr, -1, NULL, NULL, NULL, NULL);
assert(nNeedLen > 0);
VERIFY(pchString = new CHAR[nNeedLen + 1]);
if (pchString)
{
ZeroMemory(pchString, sizeof(*pchString) * (nNeedLen + 1));
WideCharToMultiByte(CP_ACP, 0, pwszStr, -1, pchString, nNeedLen + 1, 0 , 0);
pchString[nNeedLen] = 0;
}
}
}
return pchString;
}
LPWSTR WINAPI Helper_CharToWChar(LPCSTR pszStr)
{
WCHAR *pwhString = NULL;
if (pszStr)
{
LONG nLen = (LONG)strlen(pszStr);
if (nLen > 0)
{
LONG nNeedLen = MultiByteToWideChar(CP_ACP, 0, pszStr, -1, NULL, NULL);
assert(nLen > 0);
VERIFY(pwhString = new WCHAR[nNeedLen + 1]);
if (pwhString)
{
ZeroMemory(pwhString, sizeof(*pwhString) * (nNeedLen + 1));
MultiByteToWideChar(CP_ACP, 0, pszStr, -1, pwhString, nNeedLen + 1);
pwhString[nNeedLen] = 0;
}
}
}
return pwhString;
}
LPWSTR WINAPI Helper_StrDupW(LPCWSTR pwStr)
{
WCHAR *pwhString = NULL;
if (pwStr)
{
LONG nLen = (LONG)wcslen(pwStr);
if (nLen > 0)
{
VERIFY(pwhString = new WCHAR[nLen + 1]);
if (pwhString)
{
ZeroMemory(pwhString, sizeof(*pwhString) * (nLen + 1));
StringCchCopyW(pwhString, nLen + 1, pwStr);
pwhString[nLen] = 0;
}
}
}
return pwhString;
}
LPSTR WINAPI Helper_StrDupA( LPCSTR pszStr)
{
CHAR *pchString = NULL;
if (pszStr)
{
LONG nLen = (LONG)strlen(pszStr);
if (nLen > 0)
{
VERIFY(pchString = new CHAR[nLen + 1]);
if (pchString)
{
ZeroMemory(pchString, sizeof(*pchString) * (nLen + 1));
StringCchCopyA(pchString, nLen + 1, pszStr);
pchString[nLen] = 0;
}
}
}
return pchString;
}
LONG WINAPI Helper_GetPathDirectoryW(LPCWSTR pwhFilePath, LPWSTR szDirectory)
{
#ifdef WINCE
{
WCHAR szDir[MAX_DIR] = {0};
if (!pwhFilePath)
{
return -1;
}
const TCHAR *pchHead = pwhFilePath, *pszSpliter = NULL;
if (!(pszSpliter = wcsrchr(pchHead, _T('\\'))))
{
return -1;
}
pszSpliter += 1;
StringCchCopyN(szDir, _countof(szDir), pchHead, pszSpliter - pchHead);
if (szDirectory)
{
StringCchCopy(szDirectory, wcslen(szDir), szDir);
}
return wcslen(szDir);
}
#else
{
LONG nLen = 0;
WCHAR szDir[MAX_DIR] = {0};
WCHAR szPath[MAX_PATH] = {0};
if(0 == _wsplitpath_s(pwhFilePath, szPath, MAX_PATH, szDir, MAX_DIR, NULL, 0, NULL, 0))
{
StringCchCatW(szPath, _countof(szPath), szDir);
nLen = (LONG)wcslen(szPath) + 1;
}
if (szDirectory)
{
StringCchCopyW(szDirectory, nLen, szPath);
}
return wcslen(szPath);
}
#endif
}
LONG WINAPI Helper_GetPathDirectoryA(LPCSTR pchFilePath, LPSTR szDirectory)
{
#ifdef WINCE
{
LONG nLen = 0;
WCHAR szDir[MAX_PATH] = {0};
LPWSTR pszPath = CharToWChar(pchFilePath);
if (pszPath)
{
Helper_GetPathDirectoryW(pszPath, szDir);
if (szDirectory)
{
LPSTR pszDir = WCharToChar(szDir);
nLen = (LONG)strlen(pszDir) + 1;
StringCchCopyA(szDirectory, nLen, pszDir);
SAFE_DELETE_AR(pszDir);
}
}
SAFE_DELETE_AR(pszPath);
return wcslen(szDir);
}
#else
{
LONG nLen = 0;
CHAR szDir[MAX_DIR] = {0};
CHAR szPath[MAX_PATH] = {0};
if(0 == _splitpath_s(pchFilePath, szPath, MAX_PATH, szDir, MAX_DIR, NULL, 0, NULL, 0))
{
StringCchCatA(szPath, _countof(szPath), szDir);
nLen = (LONG)strlen(szPath) + 1;
}
if (szDirectory)
{
strcpy_s(szDirectory, nLen, szPath);
}
return nLen;
}
#endif
}
LPSTR WINAPI Helper_StrMoveA(LPSTR pszD, LPCSTR pszSrc)
{
if (!pszD || !pszSrc)
{
return FALSE;
}
return (LPSTR)memmove(pszD, pszSrc, (strlen(pszSrc)) + 1 * sizeof(*pszD));
}
LPWSTR WINAPI Helper_StrMoveW(LPWSTR pszD, LPCWSTR pszSrc)
{
if (!pszD || !pszSrc)
{
return FALSE;
}
return (LPWSTR)memmove(pszD, pszSrc, (wcslen(pszSrc)) + 1 * sizeof(*pszD));
}
LPSTR WINAPI Helper_StrMoveA_S(LPSTR pszD, LONG nLen, LPCSTR pszSrc)
{
if (!pszD || !pszSrc)
{
return FALSE;
}
return (LPSTR)memmove(pszD, pszSrc, (strlen(pszSrc)) + 1 * sizeof(*pszD));
}
LPWSTR WINAPI Helper_StrMoveW_S(LPWSTR pszD, LONG nLen, LPCWSTR pszSrc)
{
if (!pszD || !pszSrc)
{
return FALSE;
}
return (LPWSTR)memmove(pszD, pszSrc, (wcslen(pszSrc)) + 1 * sizeof(*pszD));
}
LONG WINAPI Helper_StrMidW(LPWSTR pszString, LONG nIndex, UINT nCount)
{
LONG nRet = -1;
if (!pszString)
{
return nRet;
}
LONG nLength = (LONG)wcslen(pszString);
assert(nIndex >= 0 && nIndex + (LONG)nCount <= nLength);
if (0 != nIndex && nCount > 0)
{
memmove(pszString, pszString + nIndex, nCount * sizeof(*pszString));
pszString[nCount] = 0;
#if defined(_DEBUG) || defined(DEBUG)
{
if (nIndex + (LONG)nCount < nLength)
{
ZeroMemory(pszString + nCount, (nLength - nCount) * sizeof(*pszString));
}
}
#endif
nRet = (LONG)wcslen(pszString);
}
return nRet;
}
LONG WINAPI Helper_StrRightW(LPWSTR pszString, UINT nCount)
{
if (!pszString)
{
return -1;
}
return Helper_StrMidW(pszString, (LONG)_tcslen(pszString) - nCount, nCount);
}
LONG WINAPI Helper_StrLeftW(LPWSTR pszString, UINT nCount)
{
if (!pszString)
{
return -1;
}
LONG nLength = (LONG)wcslen(pszString);
if (nLength >= (LONG)nCount)
{
pszString[nCount] = 0;
return (LONG)wcslen(pszString);
}
return -1;
}
void WINAPI Helper_StrTrimLeftW(LPWSTR pszString, LPCWSTR pwhTag)
{
if (!pwhTag || !pszString)
{
return;
}
if (!pszString[0])
{
return;
}
LONG nLength = (LONG)wcslen(pszString);
LONG nAmount = (LONG)wcsspn(pszString, pwhTag);
if (nAmount < nLength)
{
Helper_StrRightW(pszString, nLength - nAmount);
}
}
void WINAPI Helper_StrTrimRightW(LPWSTR pszString, LPCWSTR pszTag)
{
if (!pszTag || !pszString)
{
return;
}
LONG nAmount = 0;
BOOL blContinue = TRUE;
LONG nLength = (LONG)wcslen(pszString);
for (LONG i = 0; i < nLength && blContinue; i++)
{
if (NULL != wcschr(pszTag, pszString[nLength - i - 1]))
{
nAmount ++;
}
else
{
blContinue = FALSE;
}
}
if (!blContinue || nAmount > 0)
{
Helper_StrLeftW(pszString, nLength - nAmount);
}
}
void WINAPI Helper_StrTrimW(LPWSTR pszString, LPCWSTR pszTag)
{
Helper_StrTrimLeftW(pszString, pszTag);
Helper_StrTrimRightW(pszString, pszTag);
}
INT64 WINAPI Helper_StrGetNumberW(LPCWSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
INT64 nValue = 0;
LPCWSTR pszIndex = wcspbrk(pszString, L"0123456789-+");
if (pszIndex)
{
nValue = _wtoi64(pszIndex);
}
return nValue;
}
double WINAPI Helper_StrGetFloatW(LPCWSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
double flValue = 0;
LPCWSTR pszIndex = wcspbrk(pszString, L"0123456789.-+");
if (pszIndex)
{
#if __STDC_WANT_SECURE_LIB__
swscanf(pszIndex, L"%lf", &flValue);
#else
swscanf_s(pszIndex, L"%lf", &flValue);
#endif
//flValue = _wtof(pszIndex); atof
}
return flValue;
}
LONG WINAPI Helper_StrGetHexW(LPCWSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
LONG nValue = 0;
LPCWSTR pszIndex = wcspbrk(pszString, L"0123456789ABCDEFabcdef-+");
if (pszIndex)
{
#if _MSC_VER >= 1000
#ifdef WINCE
{
swscanf(pszIndex, L"%x", &nValue);
}
#else
{
swscanf_s(pszIndex, L"%x", &nValue);
}
#endif
#else
scanf(pszIndex, L"%x", &nValue);
#endif
}
return nValue;
}
LONG WINAPI Helper_StrMidA(LPSTR pszString, LONG nIndex, UINT nCount)
{
LONG nRet = -1;
if (!pszString)
{
return nRet;
}
LONG nLength = (LONG)strlen(pszString);
assert(nIndex >= 0 && nIndex + (LONG)nCount <= nLength);
if (0 != nIndex && nCount > 0)
{
memmove(pszString, pszString + nIndex, nCount * sizeof(*pszString));
pszString[nCount] = 0;
#if defined(_DEBUG) || defined(DEBUG)
{
if (nIndex + nCount < (LONG)nLength)
{
ZeroMemory(pszString + nCount, (nLength - nCount) * sizeof(*pszString));
}
}
#endif
nRet = (LONG)strlen(pszString);
}
return nRet;
}
LONG WINAPI Helper_StrRightA(LPSTR pszString, UINT nCount)
{
if (!pszString)
{
return -1;
}
return Helper_StrMidA(pszString, (LONG)strlen(pszString) - nCount, nCount);
}
LONG WINAPI Helper_StrLeftA(LPSTR pszString, UINT nCount)
{
if (!pszString)
{
return -1;
}
LONG nLength = (LONG)strlen(pszString);
if (nLength >= (LONG)nCount)
{
pszString[nCount] = 0;
return (LONG)strlen(pszString);
}
return -1;
}
void WINAPI Helper_StrTrimLeftA(LPSTR pszString, LPCSTR pszTag)
{
if (!pszTag || !pszString)
{
return;
}
if (!pszString[0])
{
return;
}
LONG nLength = (LONG)strlen(pszString);
LONG nAmount = (LONG)strspn(pszString, pszTag);
if (nAmount < nLength)
{
Helper_StrRightA(pszString, nLength - nAmount);
}
}
void WINAPI Helper_StrTrimRightA(LPSTR pszString, LPCSTR pszTag)
{
if (!pszTag || !pszString)
{
return;
}
LONG nAmount = 0;
BOOL blContinue = TRUE;
LONG nLength = (LONG)strlen(pszString);
for (LONG i = 0; i < nLength && blContinue; i++)
{
if (NULL != strchr(pszTag, pszString[nLength - i - 1]))
{
nAmount ++;
}
else
{
blContinue = FALSE;
}
}
if (!blContinue || nAmount > 0)
{
Helper_StrLeftA(pszString, nLength - nAmount);
}
}
void WINAPI Helper_StrTrimA(LPSTR pszString, LPCSTR pszTag)
{
Helper_StrTrimLeftA(pszString, pszTag);
Helper_StrTrimRightA(pszString, pszTag);
}
INT64 WINAPI Helper_StrGetNumberA(LPCSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
INT64 nValue = 0;
LPCSTR pszIndex = strpbrk(pszString, "0123456789-+");
if (pszIndex)
{
#if _MSC_VER >= 1000
#ifdef WINCE
{
sscanf(pszIndex, "%I64d", &nValue);
}
#else
{
sscanf_s(pszIndex, "%I64d", &nValue);
}
#endif
#else
sscanf(pszIndex, "%I64d", &nValue);
#endif
}
return nValue;
}
double WINAPI Helper_StrGetFloatA(LPCSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
double flValue = 0.0;
LPCSTR pszIndex = strpbrk(pszString, "0123456789.-+");
if (pszIndex)
{
#if _MSC_VER >= 1000
#ifdef WINCE
{
sscanf(pszIndex, "%f", &flValue);
}
#else
{
sscanf_s(pszIndex, "%f", &flValue);
}
#endif
#else
sscanf(pszIndex, "%f", &flValue);
#endif
}
return flValue;
}
LONG WINAPI Helper_StrGetHexA(LPCSTR pszString)
{
if (!pszString)
{
return 0;
}
if (!pszString[0])
{
return 0;
}
LONG nValue = 0;
LPCSTR pszIndex = strpbrk(pszString, "0123456789ABCDEFabcdef-+");
if (pszIndex)
{
#if _MSC_VER >= 1000
#ifdef WINCE
{
scanf(pszIndex, "%x", &nValue);
}
#else
{
scanf_s(pszIndex, "%x", &nValue);
}
#endif
#else
scanf(pszIndex, "%x", &nValue);
#endif
}
return nValue;
}
void WINAPI Helper_StrUpperW(LPWSTR pszString)
{
assert(pszString);
if (!pszString)
{
return;
}
if (pszString[0])
{
return;
}
wcsupr(pszString);
}
void WINAPI Helper_StrUpperA(LPSTR pszString)
{
assert(pszString);
if (!pszString)
{
return;
}
if (!pszString[0])
{
return;
}
#if _MSC_VER >= 1400
#ifdef WINCE
{
_strupr(pszString);
}
#else
{
LONG nLenght = (LONG)strlen(pszString);
_strupr_s(pszString, nLenght);
}
#endif
#else
strupr(pszString);
#endif
}
void WINAPI Helper_StrReverseW(LPWSTR pszString)
{
assert(pszString);
if (!pszString)
{
return;
}
if (!pszString[0])
{
return;
}
#if _MSC_VER > 1000
_wcsrev(pszString);
#else
wcsrev(pszString);
#endif
}
void WINAPI Helper_StrReverseA(LPSTR pszString)
{
assert(pszString);
if (!pszString)
{
return;
}
if (!pszString[0])
{
return;
}
#if _MSC_VER > 1000
_strrev(pszString);
#else
strrev(pszString);
#endif
}
void WINAPI Helper_StrReplaceW( LPWSTR pszString, WCHAR A, WCHAR B)
{
LPWSTR pszA = wcschr(pszString, A);
while(pszA)
{
*pszA ++ = B;
pszA = wcschr(pszA, A);
}
}
void WINAPI Helper_StrReplaceA( LPSTR pszString, CHAR A, CHAR B)
{
LPSTR pszA = strchr(pszString, A);
while(pszA)
{
*pszA ++ = B;
pszA = strchr(pszA, A);
}
}
void WINAPI Helper_StrRemoveW( LPWSTR pszString, WCHAR A)
{
LPWSTR pszIndexA = pszString, pszIndexB = pszString;
if (!pszString)
{
return;
}
while (*pszIndexB)
{
if (*pszIndexB != A)
{
*pszIndexA = *pszIndexB;
pszIndexA ++;
}
pszIndexB ++;
}
*pszIndexA = 0;
return;
}
void WINAPI Helper_StrRemoveA( LPSTR pszString, CHAR A)
{
LPSTR pszIndexA = pszString, pszIndexB = pszString;
if (!pszString)
{
return;
}
while (*pszIndexB)
{
if (*pszIndexB != A)
{
*pszIndexA = *pszIndexB;
pszIndexA ++;
}
pszIndexB ++;
}
*pszIndexA = 0;
return;
} | [
"[email protected]@a9ac5a9c-960a-11de-b8e1-0bcae535652c"
] | [
[
[
1,
746
]
]
] |
4951bc962c9102c2128fef0fa8644acd44cee93e | 718dc2ad71e8b39471b5bf0c6d60cbe5f5c183e1 | /soft micros/Codigo/codigo portable/Vista/DiagramaDeNavegacion/Boxes/BoxLinealVFCondicional.cpp | 8611e44c74d7e3fa6a467718e07ad147cf722d31 | [] | no_license | jonyMarino/microsdhacel | affb7a6b0ea1f4fd96d79a04d1a3ec3eaa917bca | 66d03c6a9d3a2d22b4d7104e2a38a2c9bb4061d3 | refs/heads/master | 2020-05-18T19:53:51.301695 | 2011-05-30T20:40:24 | 2011-05-30T20:40:24 | 34,532,512 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 670 | cpp | #include "BoxLinealVFCondicional.hpp"
#include "BoxLinealVF.hpp"
const struct BoxLinealVFCondicionalFactory boxLinealVFCondicionalFactory;
BoxLinealVFCondicional::BoxLinealVFCondicional(struct ConstructorBoxLinealVFCondicional * _constructor,void*_obj,uchar _numObjeto):BoxLinealVF((struct ConstructorBoxLinealVF * )_constructor),constructor(_constructor),obj(_obj),numObj(_numObjeto){
if((constructor->super).propiedades[(*(constructor->getNroProp))(obj)]){ //la propiedad es distinta de NULL??
setNumProp((*(constructor->getNroProp))(obj));
mostrarPropiedad(obj,numObj);
}
}
BoxLinealVFCondicional::~BoxLinealVFCondicional(){
}
| [
"nicopimen@9fc3b3b2-dce3-11dd-9b7c-b771bf68b549"
] | [
[
[
1,
20
]
]
] |
9d13b6ee3b70cc8d9adafd4d243988d0c346e4ee | 21da454a8f032d6ad63ca9460656c1e04440310e | /src/wcpp/wspr/wsuMutex.h | 9bd4137f212b282e517153f8d966614edfea0be3 | [] | no_license | merezhang/wcpp | d9879ffb103513a6b58560102ec565b9dc5855dd | e22eb48ea2dd9eda5cd437960dd95074774b70b0 | refs/heads/master | 2021-01-10T06:29:42.908096 | 2009-08-31T09:20:31 | 2009-08-31T09:20:31 | 46,339,619 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 409 | h | #pragma once
#include "wsuSyncObject.h"
class ws_mutex;
class wsuMutex : public wsuSyncObject
{
private:
ws_mutex * m_pMutex;
private:
const wsuMutex & operator=(const wsuMutex & src);
explicit wsuMutex(const wsuMutex & init);
public:
explicit wsuMutex(void);
~wsuMutex(void);
public:
WS_VFUNC( void, Lock )(void);
WS_VFUNC( void, Unlock )(void);
};
| [
"xukun0217@98f29a9a-77f1-11de-91f8-ab615253d9e8"
] | [
[
[
1,
23
]
]
] |
ffeb045bafbf825504d7c614f05d1e7fa4745632 | b08e948c33317a0a67487e497a9afbaf17b0fc4c | /Display/DisplayUtil.cpp | 23b5516689cb7bb32280e8037927747092f9e9d2 | [] | no_license | 15831944/bastionlandscape | e1acc932f6b5a452a3bd94471748b0436a96de5d | c8008384cf4e790400f9979b5818a5a3806bd1af | refs/heads/master | 2023-03-16T03:28:55.813938 | 2010-05-21T15:00:07 | 2010-05-21T15:00:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,216 | cpp | #include "stdafx.h"
#include "../Display/Display.h"
namespace ElixirEngine
{
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
unsigned int Display::GetFormatBitsPerPixel(const D3DFORMAT& _eFormat)
{
switch (_eFormat)
{
//case D3DFMT_UNKNOWN:
case D3DFMT_R8G8B8:
{
return 24;
}
case D3DFMT_A8R8G8B8:
case D3DFMT_X8R8G8B8:
case D3DFMT_A2B10G10R10:
case D3DFMT_A8B8G8R8:
case D3DFMT_X8B8G8R8:
case D3DFMT_G16R16:
case D3DFMT_A2R10G10B10:
case D3DFMT_X8L8V8U8:
case D3DFMT_Q8W8V8U8:
case D3DFMT_V16U16:
case D3DFMT_A2W10V10U10:
case D3DFMT_D32:
case D3DFMT_D24S8:
case D3DFMT_D24X8:
case D3DFMT_D24X4S4:
case D3DFMT_D32F_LOCKABLE:
case D3DFMT_D24FS8:
#if !defined(D3D_DISABLE_9EX)
case D3DFMT_D32_LOCKABLE:
#endif // !D3D_DISABLE_9EX
case D3DFMT_INDEX32:
case D3DFMT_G16R16F:
case D3DFMT_R32F:
{
return 32;
}
case D3DFMT_R5G6B5:
case D3DFMT_X1R5G5B5:
case D3DFMT_A1R5G5B5:
case D3DFMT_A4R4G4B4:
case D3DFMT_A8R3G3B2:
case D3DFMT_X4R4G4B4:
case D3DFMT_A8L8:
case D3DFMT_V8U8:
case D3DFMT_L6V5U5:
case D3DFMT_R8G8_B8G8:
case D3DFMT_G8R8_G8B8:
case D3DFMT_D16_LOCKABLE:
case D3DFMT_D15S1:
case D3DFMT_D16:
case D3DFMT_L16:
case D3DFMT_INDEX16:
case D3DFMT_R16F:
case D3DFMT_CxV8U8:
{
return 16;
}
case D3DFMT_R3G3B2:
case D3DFMT_A8:
case D3DFMT_A8P8:
case D3DFMT_P8:
case D3DFMT_L8:
case D3DFMT_A4L4:
#if !defined(D3D_DISABLE_9EX)
case D3DFMT_S8_LOCKABLE:
#endif // !D3D_DISABLE_9EX
{
return 8;
}
case D3DFMT_A16B16G16R16:
case D3DFMT_G32R32F:
case D3DFMT_Q16W16V16U16:
case D3DFMT_A16B16G16R16F:
{
return 64;
}
case D3DFMT_A32B32G32R32F:
{
return 128;
}
#if !defined(D3D_DISABLE_9EX)
case D3DFMT_A1:
{
return 1;
}
#endif // !D3D_DISABLE_9EX
case D3DFMT_UYVY:
case D3DFMT_YUY2:
case D3DFMT_DXT1:
case D3DFMT_DXT2:
case D3DFMT_DXT3:
case D3DFMT_DXT4:
case D3DFMT_DXT5:
case D3DFMT_VERTEXDATA:
case D3DFMT_MULTI2_ARGB8:
#if !defined(D3D_DISABLE_9EX)
case D3DFMT_BINARYBUFFER:
#endif // !D3D_DISABLE_9EX
{
return 0;
}
}
return 0;
}
bool Display::IsPowerOf2(const unsigned int& _uValue, UIntPtr _pPowerLevel)
{
unsigned int uTemp = _uValue;
unsigned int uBitsCount = 0;
bool bResult = false;
if (NULL == _pPowerLevel)
{
while (1 != uTemp)
{
uBitsCount = (0x1 == (0x1 & uTemp)) ? (uBitsCount + 1) : uBitsCount;
uTemp >>= 1;
}
uBitsCount = (0x1 == (0x1 & uTemp)) ? (uBitsCount + 1) : uBitsCount;
}
else
{
(*_pPowerLevel) = 0;
while (1 != uTemp)
{
uBitsCount = (0x1 == (0x1 & uTemp)) ? (uBitsCount + 1) : uBitsCount;
uTemp >>= 1;
++(*_pPowerLevel);
}
uBitsCount = (0x1 == (0x1 & uTemp)) ? (uBitsCount + 1) : uBitsCount;
}
bResult = (1 == uBitsCount); // is it a power of 2 number ??
return bResult;
}
D3DFORMAT Display::StringToDisplayFormat(const string& _strFormatName, const D3DFORMAT& _uDefaultFormat)
{
if (false != s_mDisplayFormat.empty())
{
InitDisplayFormatMap();
}
Key uFormatNameKey = MakeKey(_strFormatName);
if (s_mDisplayFormat.end() == s_mDisplayFormat.find(uFormatNameKey))
{
return _uDefaultFormat;
}
return s_mDisplayFormat[uFormatNameKey];
}
D3DFORMAT Display::KeyToDisplayFormat(const Key& _uFormatNameKey, const D3DFORMAT& _uDefaultFormat)
{
if (false != s_mDisplayFormat.empty())
{
InitDisplayFormatMap();
}
if (s_mDisplayFormat.end() == s_mDisplayFormat.find(_uFormatNameKey))
{
return _uDefaultFormat;
}
return s_mDisplayFormat[_uFormatNameKey];
}
void Display::InitDisplayFormatMap()
{
#define AddToDisplayFormatMap(Format) s_mDisplayFormat[MakeKey(string(#Format))] = Format;
AddToDisplayFormatMap(D3DFMT_UNKNOWN);
AddToDisplayFormatMap(D3DFMT_R8G8B8);
AddToDisplayFormatMap(D3DFMT_A8R8G8B8);
AddToDisplayFormatMap(D3DFMT_X8R8G8B8);
AddToDisplayFormatMap(D3DFMT_A2B10G10R10);
AddToDisplayFormatMap(D3DFMT_A8B8G8R8);
AddToDisplayFormatMap(D3DFMT_X8B8G8R8);
AddToDisplayFormatMap(D3DFMT_G16R16);
AddToDisplayFormatMap(D3DFMT_A2R10G10B10);
AddToDisplayFormatMap(D3DFMT_X8L8V8U8);
AddToDisplayFormatMap(D3DFMT_Q8W8V8U8);
AddToDisplayFormatMap(D3DFMT_V16U16);
AddToDisplayFormatMap(D3DFMT_A2W10V10U10);
AddToDisplayFormatMap(D3DFMT_D32);
AddToDisplayFormatMap(D3DFMT_D24S8);
AddToDisplayFormatMap(D3DFMT_D24X8);
AddToDisplayFormatMap(D3DFMT_D24X4S4);
AddToDisplayFormatMap(D3DFMT_D32F_LOCKABLE);
AddToDisplayFormatMap(D3DFMT_D24FS8);
#if !defined(D3D_DISABLE_9EX)
AddToDisplayFormatMap(D3DFMT_D32_LOCKABLE);
#endif // !D3D_DISABLE_9EX
AddToDisplayFormatMap(D3DFMT_INDEX32);
AddToDisplayFormatMap(D3DFMT_G16R16F);
AddToDisplayFormatMap(D3DFMT_R32F);
AddToDisplayFormatMap(D3DFMT_R5G6B5);
AddToDisplayFormatMap(D3DFMT_X1R5G5B5);
AddToDisplayFormatMap(D3DFMT_A1R5G5B5);
AddToDisplayFormatMap(D3DFMT_A4R4G4B4);
AddToDisplayFormatMap(D3DFMT_A8R3G3B2);
AddToDisplayFormatMap(D3DFMT_X4R4G4B4);
AddToDisplayFormatMap(D3DFMT_A8L8);
AddToDisplayFormatMap(D3DFMT_V8U8);
AddToDisplayFormatMap(D3DFMT_L6V5U5);
AddToDisplayFormatMap(D3DFMT_R8G8_B8G8);
AddToDisplayFormatMap(D3DFMT_G8R8_G8B8);
AddToDisplayFormatMap(D3DFMT_D16_LOCKABLE);
AddToDisplayFormatMap(D3DFMT_D15S1);
AddToDisplayFormatMap(D3DFMT_D16);
AddToDisplayFormatMap(D3DFMT_L16);
AddToDisplayFormatMap(D3DFMT_INDEX16);
AddToDisplayFormatMap(D3DFMT_R16F);
AddToDisplayFormatMap(D3DFMT_CxV8U8);
AddToDisplayFormatMap(D3DFMT_R3G3B2);
AddToDisplayFormatMap(D3DFMT_A8);
AddToDisplayFormatMap(D3DFMT_A8P8);
AddToDisplayFormatMap(D3DFMT_P8);
AddToDisplayFormatMap(D3DFMT_L8);
AddToDisplayFormatMap(D3DFMT_A4L4);
#if !defined(D3D_DISABLE_9EX)
AddToDisplayFormatMap(D3DFMT_S8_LOCKABLE);
#endif // !D3D_DISABLE_9EX
AddToDisplayFormatMap(D3DFMT_A16B16G16R16);
AddToDisplayFormatMap(D3DFMT_G32R32F);
AddToDisplayFormatMap(D3DFMT_Q16W16V16U16);
AddToDisplayFormatMap(D3DFMT_A16B16G16R16F);
AddToDisplayFormatMap(D3DFMT_A32B32G32R32F);
#if !defined(D3D_DISABLE_9EX)
AddToDisplayFormatMap(D3DFMT_A1);
#endif // !D3D_DISABLE_9EX
AddToDisplayFormatMap(D3DFMT_UYVY);
AddToDisplayFormatMap(D3DFMT_YUY2);
AddToDisplayFormatMap(D3DFMT_DXT1);
AddToDisplayFormatMap(D3DFMT_DXT2);
AddToDisplayFormatMap(D3DFMT_DXT3);
AddToDisplayFormatMap(D3DFMT_DXT4);
AddToDisplayFormatMap(D3DFMT_DXT5);
AddToDisplayFormatMap(D3DFMT_VERTEXDATA);
AddToDisplayFormatMap(D3DFMT_MULTI2_ARGB8);
#if !defined(D3D_DISABLE_9EX)
AddToDisplayFormatMap(D3DFMT_BINARYBUFFER);
#endif // !defined(D3D_DISABLE_9EX)
#undef AddToDisplayFormatMap
}
}
| [
"voodoohaust@97c0069c-804f-11de-81da-11cc53ed4329"
] | [
[
[
1,
252
]
]
] |
3e1bc860f80d107c1f58a2c620708d324c0aabed | 0f8559dad8e89d112362f9770a4551149d4e738f | /Wall_Destruction/Havok/Source/Physics/Dynamics/Constraint/Chain/StiffSpring/hkpStiffSpringChainData.h | 9954f08de1230d21127cde7b52f55aacbd851f5a | [] | no_license | TheProjecter/olafurabertaymsc | 9360ad4c988d921e55b8cef9b8dcf1959e92d814 | 456d4d87699342c5459534a7992f04669e75d2e1 | refs/heads/master | 2021-01-10T15:15:49.289873 | 2010-09-20T12:58:48 | 2010-09-20T12:58:48 | 45,933,002 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,922 | h | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#ifndef HK_DYNAMICS2_STIFF_SPRING_CHAIN_H
#define HK_DYNAMICS2_STIFF_SPRING_CHAIN_H
#include <Physics/ConstraintSolver/Solve/hkpSolverResults.h>
#include <Physics/ConstraintSolver/Constraint/Atom/hkpConstraintAtom.h>
#include <Physics/Dynamics/Constraint/Chain/hkpConstraintChainData.h>
#include <Physics/Dynamics/Action/hkpArrayAction.h>
/// A chain of stiff springs
class hkpStiffSpringChainData : public hkpConstraintChainData
{
public:
HK_DECLARE_REFLECTION();
HK_DECLARE_CLASS_ALLOCATOR( HK_MEMORY_CLASS_CONSTRAINT ); // and action too
hkpStiffSpringChainData();
~hkpStiffSpringChainData();
/// Not implemented. Returns always true.
hkBool isValid() const { return true; }
/// Get type from this constraint
virtual int getType() const;
/// Returns the number of stored constraint infos.
virtual int getNumConstraintInfos() { return m_infos.getSize(); }
/// Adds a constraint info to the chain.
/// Pivot points are specified in the local space of the bodies.
/// Spring length must be supplied.
void addConstraintInfoInBodySpace(const hkVector4& pivotInA, const hkVector4& pivotInB, hkReal springLength);
public:
struct Runtime
{
/// Runtime only stores solver results. The number of solver results is (hkpStiffSpringConstraintData::SOLVER_RESULT_MAX * getNumConstraintInfos()
/// == 1 * getNumConstraintInfos()).
/// Note: when the instance uses less constraints than there are constraintInfos, then the hkpSolverResults at the end of the array are uninitialized.
inline const hkpSolverResults* getSolverResults() { return reinterpret_cast<hkpSolverResults*>(this); }
};
inline const Runtime* getRuntime( hkpConstraintRuntime* runtime )
{
return reinterpret_cast<Runtime*>(runtime);
}
public:
//
// Internal functions
//
/// Interface implementation.
virtual void buildJacobian( const hkpConstraintQueryIn &in, hkpConstraintQueryOut &out );
/// Interface implementation.
virtual void getConstraintInfo( hkpConstraintData::ConstraintInfo& info ) const;
/// Interface implementation.
virtual void getRuntimeInfo( hkBool wantRuntime, hkpConstraintData::RuntimeInfo& infoOut ) const;
public:
/// Serialization ctor.
hkpStiffSpringChainData(hkFinishLoadedObjectFlag f);
public:
struct hkpBridgeAtoms m_atoms;
/// This structure holds information needed for an individual constraint in the chain.
struct ConstraintInfo
{
HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, hkpStiffSpringChainData::ConstraintInfo );
HK_DECLARE_REFLECTION();
/// Constraint's pivot point in bodyA's space.
hkVector4 m_pivotInA;
/// Constraint's pivot point in bodyB's space.
hkVector4 m_pivotInB;
/// Requested distance between the pivot points of the two bodies. It is advised to specify a non-zero value, otherwise the constraint is instable.
hkReal m_springLength;
};
/// Constraint infos for the chain's constraints.
hkArray<struct ConstraintInfo> m_infos;
/// Solver tau, this overrides the global value from hkpSolverInfo when processing the chained constraints.
hkReal m_tau;
/// Solver damping, this overrides the global value from hkpSolverInfo when processing the chained constraints.
hkReal m_damping;
/// Constraint force mixing parameter. Value added to the diagonal of the constraint matrix.
/// Should be zero or tiny, e.g. a fraction of HK_REAL_EPSILON. When this value is zero, then some chain configurations
/// may result in a division by zero when solving.
hkReal m_cfm;
};
#endif // HK_DYNAMICS2_STIFF_SPRING_CHAIN_H
/*
* Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20091222)
*
* Confidential Information of Havok. (C) Copyright 1999-2009
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available at www.havok.com/tryhavok.
*
*/
| [
"[email protected]"
] | [
[
[
1,
134
]
]
] |
29357f8543bce95c8a832c9fc34b2af106899b11 | 4a2b2d6d07714e82ecf94397ea6227edbd7893ad | /Curl/CurlTest/AssemblyInfo.cpp | 9e3568efa6ed79819f464975a4ef2b1316e65ee6 | [] | no_license | intere/tmee | 8b0a6dd4651987a580e3194377cfb999e9615758 | 327fed841df6351dc302071614a9600e2fa67f5f | refs/heads/master | 2021-01-25T07:28:47.788280 | 2011-07-21T04:24:31 | 2011-07-21T04:24:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,392 | cpp | namespace eric
{
};
/*
//#include "stdafx.h"
//#using <mscorlib.dll>
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("")];
[assembly:AssemblyCopyrightAttribute("")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("1.0.*")];
//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
// (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key.
// (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be
// relative to the project directory.
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this.
//
[assembly:AssemblyDelaySignAttribute(false)];
[assembly:AssemblyKeyFileAttribute("")];
[assembly:AssemblyKeyNameAttribute("")];
*/ | [
"intere@8c6822e2-464b-4b1f-8ae9-3c1f0a8e8225"
] | [
[
[
1,
67
]
]
] |
eaf4fa65bac70def1cce1fd33b7894a4a03444c1 | 20cf43a2e1854d71696a6264dea4ea8cbfdb16f2 | /WinNT/comm_nt_server/CommonClasses.h | bca35b6e4b38f15783908e6b4277a76c0b699b77 | [] | no_license | thebruno/comm-nt | fb0ece0a8d36715a8f0199ba3ce9f37859170ee3 | 6ba36941b123c272efe8d81b55555d561d8842f4 | refs/heads/master | 2016-09-07T19:00:59.817929 | 2010-01-14T20:38:58 | 2010-01-14T20:38:58 | 32,205,785 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,000 | h | #ifndef COMMON_CLASSES_H
#define COMMON_CLASSES_H
#include "stdafx.h"
#include "Utilities.h"
class Serializable{
virtual std::string ToString(char separator) = 0;
virtual Result Parse(std::string &s) = 0;
};
std::string DateTimeNow();
#define MESSAGE_DELIMITER (char)0xFF // add at the end of every message while sending
#define MESSAGE_SEPARATOR (char)0xFE // separates fields in the message
#define MESSAGE_GROUP_USER_SEPARATOR (char)0xFD // separates users in group
#define MESSAGE_USER_SEPARATOR (char)0xFC // separate user fields
#define MESSAGE_QUEUE_LENGTH 1024
enum MessageType
{
// s = server
// c = client
// | - begining end ending of message
// # - MESSAGE_SEPARATOR
// % - MESSAGE_GROUP_USER_SEPARATOR
// $ - MESSAGE_USER_SEPARATOR
MESSAGETYPE_NOTSET,
LOGIN, // add user to list on server, c->s, |LOGIN#SENDER| ==> |LOGIN#LOGIN$IP|
LOGOUT, // disconnectiong from server, c->s, |LOGOUT#SENDER|
RESULT, // result of performed operation, s->c, |RESULT#RECEIVER#OPERATION#OPERATION RESULT#ADDITIONAL INFO|
USERLIST, // list of users, s->c, |USERLIST#RECEIVER#USERS GROUP#| ==> |USERLIST#TO USER#USER1%USER2%...%USERN|, TO U
MESSAGE, // simple text message, c->s->c, |MESSAGE#SENDER#RECEIVER|
GROUPMESSAGE, // simple text message for group of recipients, c->s->c1, c2, c3, |MESSAGE#SENDER#RECEIVER#USERS GROUP|
};
std::string ToString(MessageType command);
MessageType ToMessageType(std::string s);
std::string ToString(Result command);
Result ToResult(std::string s);
//HANDLE InputMutex;
//InputMutex = CreateMutex(0, false, 0);
//CloseHandle(InputMutex);
struct User : public Serializable{
std::string Login;
std::string IP;
User(std::string login, std::string ip);
User();
virtual ~User();
virtual std::string ToString(char separator = MESSAGE_USER_SEPARATOR);
virtual Result Parse(std::string &object);
bool operator==(const User & u2) const;
bool operator<(const User & u2) const;
};
struct Group: public Serializable{
std::list<User > GroupMembers;
Group(std::list<User> &u);
Group();
virtual ~Group();
virtual std::string ToString(char separator = MESSAGE_GROUP_USER_SEPARATOR);
virtual Result Parse(std::string &object);
bool operator==(const Group & u1) const;
};
struct Message: public Serializable {
MessageType Type;
std::string Created;
MessageType PreviousOperation;
Result PreviousResult;
std::string PreviusOperationInfo;
User Sender;
User Receiver;
Group InvolvedGroup;
std::string Text;
Message(MessageType type, std::string created, User sender, User receiver, Group involvedGroup, std::string text);
Message(MessageType type, std::string created, User receiver, MessageType previousOperation, Result previousResult, std::string previusOperationInfo);
Message();
virtual ~Message();
virtual std::string ToString(char separator = MESSAGE_SEPARATOR);
virtual Result Parse(std::string &object);
};
#endif
| [
"konrad.balys@08f01046-b83b-11de-9b33-83dc4fd2bb11"
] | [
[
[
1,
89
]
]
] |
c2cf3778af1fcdaa9b507c0e0f4ab1fcefcd55b4 | 05869e5d7a32845b306353bdf45d2eab70d5eddc | /soft/application/NetworkSimulator/SimulatorStart.h | 87792c3ed6ab889671e1194bad3795a504fe0f81 | [] | no_license | shenfahsu/sc-fix | beb9dc8034f2a8fd9feb384155fa01d52f3a4b6a | ccc96bfaa3c18f68c38036cf68d3cb34ca5b40cd | refs/heads/master | 2020-07-14T16:13:47.424654 | 2011-07-22T16:46:45 | 2011-07-22T16:46:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,252 | h | // SimulatorStart.h: interface for the CSimulatorStart class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_SIMULATORSTART_H__C1E9D920_58D4_4913_840D_11A899439429__INCLUDED_)
#define AFX_SIMULATORSTART_H__C1E9D920_58D4_4913_840D_11A899439429__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifdef _EXPORT_NETWORK_SIMULATOR
#define EXPORT_NETWORK_SIMULATOR __declspec(dllexport)
#else
#define EXPORT_NETWORK_SIMULATOR
#endif
typedef void* oslMsgqid_handle;
typedef void* MYQUEUE_HANDLE;
typedef unsigned int (*NWRECEIVEQ)(oslMsgqid_handle msgqid, MYQUEUE_HANDLE Message);
typedef void (*NWWRITEQ)(MYQUEUE_HANDLE Message);
class EXPORT_NETWORK_SIMULATOR CSimulatorStart
{
public:
CSimulatorStart();
virtual ~CSimulatorStart();
public:
BOOL Bootup();
void ShowSimulator();
BOOL InitSimulator(int nXPos,int nYPos);
BOOL IsInit();
void SetReadQueueHandle(oslMsgqid_handle handle);
void SetReadQueueHandler(NWRECEIVEQ pRecvHandler);
void SetWriteQueueHandler(NWWRITEQ pWriteHandler);
void SetWriteQueueHandle(oslMsgqid_handle handle);
};
#endif // !defined(AFX_SIMULATORSTART_H__C1E9D920_58D4_4913_840D_11A899439429__INCLUDED_)
| [
"windyin@2490691b-6763-96f4-2dba-14a298306784"
] | [
[
[
1,
41
]
]
] |
e91f359fd45b0a57d813c313f3eee5290252a9a7 | 01c236af2890d74ca5b7c25cec5e7b1686283c48 | /Src/ChooseGameTypeForm.h | 0b79a18bcb03dd117b0dd30b70e6881551d4c21b | [
"MIT"
] | permissive | muffinista/palm-pitch | 80c5900d4f623204d3b837172eefa09c4efbe5e3 | aa09c857b1ccc14672b3eb038a419bd13abc0925 | refs/heads/master | 2021-01-19T05:43:04.740676 | 2010-07-08T14:42:18 | 2010-07-08T14:42:18 | 763,958 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 931 | h | #ifndef GTFORM_H_
#define GTFORM_H_
class CChooseGameTypeDialog : public CModalForm {
public:
// constructor
CChooseGameTypeDialog() :
CModalForm(ChooseGameTypeForm)
{ }
// Form event handlers
Boolean OnOpen(EventType* pEvent, Boolean& bHandled);
Boolean OnClose(EventType* pEvent, Boolean& bHandled);
// Command handlers
Boolean OnOK(EventPtr pEvent, Boolean& bHandled);
Boolean OnCancel(EventPtr pEvent, Boolean& bHandled);
Boolean CutThroat();
// Event map
BEGIN_EVENT_MAP(CModalForm)
EVENT_MAP_COMMAND_ENTRY(GameTypeOKButton, OnOK)
EVENT_MAP_COMMAND_ENTRY(GameTypeCancelButton, OnCancel)
END_EVENT_MAP()
// Post-Event map
BEGIN_POST_EVENT_MAP(CModalForm)
POST_EVENT_MAP_ENTRY(frmOpenEvent, OnOpen)
POST_EVENT_MAP_ENTRY(frmCloseEvent, OnClose)
END_POST_EVENT_MAP()
protected:
CListCtrl m_GameType;
Boolean _cutthroat;
};
#endif // PREFSFORM_H_
| [
"[email protected]"
] | [
[
[
1,
42
]
]
] |
a875ff2e8c299b674c4d32cee23d8722d611ecf1 | f8b364974573f652d7916c3a830e1d8773751277 | /emulator/allegrex/disassembler/MTHI.h | b2ee5549d0a5dc84a62ced819512b64d537479b7 | [] | no_license | lemmore22/pspe4all | 7a234aece25340c99f49eac280780e08e4f8ef49 | 77ad0acf0fcb7eda137fdfcb1e93a36428badfd0 | refs/heads/master | 2021-01-10T08:39:45.222505 | 2009-08-02T11:58:07 | 2009-08-02T11:58:07 | 55,047,469 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 309 | h | /* MTHI */
void AllegrexInstructionTemplate< 0x00000011, 0xfc1fffff >::disassemble(u32 address, u32 opcode, char *opcode_name, char *operands, char *comment)
{
using namespace Allegrex;
::strcpy(opcode_name, "mthi");
::sprintf(operands, "%s", gpr_name[rs(opcode)]);
::strcpy(comment, "");
}
| [
"[email protected]"
] | [
[
[
1,
9
]
]
] |
10666a604584d1296ec17bc1c0f75999c22feee2 | 501b10e5d60b94df94391345cbb61893fdc09e0d | /Source/Transforms/itkAdvancedBSplineDeformableTransform.h | 03d30327eee3505bb4bacb9e03fe41e9b31bec65 | [] | no_license | midas-journal/midas-journal-756 | 944187f60c294efc1bf17cd99791d7e8e01b6d7b | bdf6c3e99c074a6eb035e0941bffb265d2539514 | refs/heads/master | 2021-01-25T03:49:26.250649 | 2011-08-22T13:47:31 | 2011-08-22T13:47:31 | 2,248,740 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,149 | h | /*======================================================================
This file is part of the elastix software.
Copyright (c) University Medical Center Utrecht. All rights reserved.
See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php for
details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
======================================================================*/
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkAdvancedBSplineDeformableTransform.h,v $
Language: C++
Date: $Date: 2008-04-11 16:28:11 $
Version: $Revision: 1.38 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkAdvancedBSplineDeformableTransform_h
#define __itkAdvancedBSplineDeformableTransform_h
#include "itkAdvancedBSplineDeformableTransformBase.h"
#include "itkImage.h"
#include "itkImageRegion.h"
#include "itkBSplineInterpolationWeightFunction2.h"
#include "itkBSplineInterpolationDerivativeWeightFunction.h"
#include "itkBSplineInterpolationSecondOrderDerivativeWeightFunction.h"
namespace itk
{
/** \class AdvancedBSplineDeformableTransform
* \brief Deformable transform using a BSpline representation
*
* This class encapsulates a deformable transform of points from one
* N-dimensional one space to another N-dimensional space.
* The deformation field is modeled using B-splines.
* A deformation is defined on a sparse regular grid of control points
* \f$ \vec{\lambda}_j \f$ and is varied by defining a deformation
* \f$ \vec{g}(\vec{\lambda}_j) \f$ of each control point.
* The deformation \f$ D(\vec{x}) \f$ at any point \f$ \vec{x} \f$
* is obtained by using a B-spline interpolation kernel.
*
* The deformation field grid is defined by a user specified GridRegion,
* GridSpacing and GridOrigin. Each grid/control point has associated with it
* N deformation coefficients \f$ \vec{\delta}_j \f$, representing the N
* directional components of the deformation. Deformation outside the grid
* plus support region for the BSpline interpolation is assumed to be zero.
*
* Additionally, the user can specified an addition bulk transform \f$ B \f$
* such that the transformed point is given by:
* \f[ \vec{y} = B(\vec{x}) + D(\vec{x}) \f]
*
* The parameters for this transform is N x N-D grid of spline coefficients.
* The user specifies the parameters as one flat array: each N-D grid
* is represented by an array in the same way an N-D image is represented
* in the buffer; the N arrays are then concatentated together on form
* a single array.
*
* For efficiency, this transform does not make a copy of the parameters.
* It only keeps a pointer to the input parameters and assumes that the memory
* is managed by the caller.
*
* The following illustrates the typical usage of this class:
* \verbatim
* typedef AdvancedBSplineDeformableTransform<double,2,3> TransformType;
* TransformType::Pointer transform = TransformType::New();
*
* transform->SetGridRegion( region );
* transform->SetGridSpacing( spacing );
* transform->SetGridOrigin( origin );
*
* // NB: the region must be set first before setting the parameters
*
* TransformType::ParametersType parameters(
* transform->GetNumberOfParameters() );
*
* // Fill the parameters with values
*
* transform->SetParameters( parameters )
*
* outputPoint = transform->TransformPoint( inputPoint );
*
* \endverbatim
*
* An alternative way to set the B-spline coefficients is via array of
* images. The grid region, spacing and origin information is taken
* directly from the first image. It is assumed that the subsequent images
* are the same buffered region. The following illustrates the API:
* \verbatim
*
* TransformType::ImageConstPointer images[2];
*
* // Fill the images up with values
*
* transform->SetCoefficientImages( images );
* outputPoint = transform->TransformPoint( inputPoint );
*
* \endverbatim
*
* Warning: use either the SetParameters() or SetCoefficientImage()
* API. Mixing the two modes may results in unexpected results.
*
* The class is templated coordinate representation type (float or double),
* the space dimension and the spline order.
*
* \ingroup Transforms
*/
template <
class TScalarType = double, // Data type for scalars
unsigned int NDimensions = 3, // Number of dimensions
unsigned int VSplineOrder = 3 > // Spline order
class ITK_EXPORT AdvancedBSplineDeformableTransform
: public AdvancedBSplineDeformableTransformBase< TScalarType, NDimensions >
{
public:
/** Standard class typedefs. */
typedef AdvancedBSplineDeformableTransform Self;
typedef AdvancedBSplineDeformableTransformBase<
TScalarType, NDimensions > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through the object factory. */
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( AdvancedBSplineDeformableTransform, AdvancedBSplineDeformableTransformBase );
/** Dimension of the domain space. */
itkStaticConstMacro( SpaceDimension, unsigned int, NDimensions );
/** The BSpline order. */
itkStaticConstMacro( SplineOrder, unsigned int, VSplineOrder );
/** Typedefs from Superclass. */
typedef typename Superclass::ParametersType ParametersType;
typedef typename Superclass::JacobianType JacobianType;
typedef typename Superclass::ScalarType ScalarType;
typedef typename Superclass::InputPointType InputPointType;
typedef typename Superclass::OutputPointType OutputPointType;
typedef typename Superclass::InputVectorType InputVectorType;
typedef typename Superclass::OutputVectorType OutputVectorType;
typedef typename Superclass::InputVnlVectorType InputVnlVectorType;
typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType;
typedef typename Superclass::InputCovariantVectorType
InputCovariantVectorType;
typedef typename Superclass::OutputCovariantVectorType
OutputCovariantVectorType;
typedef typename Superclass
::NonZeroJacobianIndicesType NonZeroJacobianIndicesType;
typedef typename Superclass::SpatialJacobianType SpatialJacobianType;
typedef typename Superclass
::JacobianOfSpatialJacobianType JacobianOfSpatialJacobianType;
typedef typename Superclass::SpatialHessianType SpatialHessianType;
typedef typename Superclass
::JacobianOfSpatialHessianType JacobianOfSpatialHessianType;
typedef typename Superclass::InternalMatrixType InternalMatrixType;
/** Parameters as SpaceDimension number of images. */
typedef typename Superclass::PixelType PixelType;
typedef typename Superclass::ImageType ImageType;
typedef typename Superclass::ImagePointer ImagePointer;
/** Typedefs for specifying the extend to the grid. */
typedef typename Superclass::RegionType RegionType;
typedef typename Superclass::IndexType IndexType;
typedef typename Superclass::SizeType SizeType;
typedef typename Superclass::SpacingType SpacingType;
typedef typename Superclass::DirectionType DirectionType;
typedef typename Superclass::OriginType OriginType;
typedef typename Superclass::GridOffsetType GridOffsetType;
/** This method specifies the region over which the grid resides. */
virtual void SetGridRegion( const RegionType& region );
/** Typedef of the bulk transform. */
typedef typename Superclass::BulkTransformType BulkTransformType;
typedef typename Superclass::BulkTransformPointer BulkTransformPointer;
/** Transform points by a BSpline deformable transformation. */
OutputPointType TransformPoint( const InputPointType & point ) const;
/** Interpolation weights function type. */
typedef BSplineInterpolationWeightFunction2< ScalarType,
itkGetStaticConstMacro( SpaceDimension ),
itkGetStaticConstMacro( SplineOrder ) > WeightsFunctionType;
typedef typename WeightsFunctionType::WeightsType WeightsType;
typedef typename WeightsFunctionType::ContinuousIndexType ContinuousIndexType;
typedef BSplineInterpolationDerivativeWeightFunction<
ScalarType,
itkGetStaticConstMacro( SpaceDimension ),
itkGetStaticConstMacro( SplineOrder ) > DerivativeWeightsFunctionType;
typedef BSplineInterpolationSecondOrderDerivativeWeightFunction<
ScalarType,
itkGetStaticConstMacro( SpaceDimension ),
itkGetStaticConstMacro( SplineOrder ) > SODerivativeWeightsFunctionType;
/** Parameter index array type. */
typedef typename Superclass::ParameterIndexArrayType ParameterIndexArrayType;
/** Transform points by a BSpline deformable transformation.
* On return, weights contains the interpolation weights used to compute the
* deformation and indices of the x (zeroth) dimension coefficient parameters
* in the support region used to compute the deformation.
* Parameter indices for the i-th dimension can be obtained by adding
* ( i * this->GetNumberOfParametersPerDimension() ) to the indices array.
*/
virtual void TransformPoint(
const InputPointType & inputPoint,
OutputPointType & outputPoint,
WeightsType & weights,
ParameterIndexArrayType & indices,
bool & inside ) const;
/** Get number of weights. */
unsigned long GetNumberOfWeights( void ) const
{
return this->m_WeightsFunction->GetNumberOfWeights();
}
unsigned int GetNumberOfAffectedWeights( void ) const;
virtual unsigned long GetNumberOfNonZeroJacobianIndices( void ) const;
/** Whether the advanced transform has nonzero matrices. */
virtual bool GetHasNonZeroSpatialHessian( void ) const
{
return true;
}
virtual bool HasNonZeroJacobianOfSpatialHessian( void ) const
{
return true;
}
/** Compute the Jacobian matrix of the transformation at one point. */
virtual const JacobianType & GetJacobian( const InputPointType & point ) const;
/** Compute the Jacobian of the transformation. */
virtual void GetJacobian(
const InputPointType & ipp,
WeightsType & weights,
ParameterIndexArrayType & indices ) const;
/** Compute the Jacobian of the transformation. */
virtual void GetJacobian(
const InputPointType & ipp,
JacobianType & j,
NonZeroJacobianIndicesType & ) const;
/** Compute the spatial Jacobian of the transformation. */
virtual void GetSpatialJacobian(
const InputPointType & ipp,
SpatialJacobianType & sj ) const;
/** Compute the spatial Hessian of the transformation. */
virtual void GetSpatialHessian(
const InputPointType & ipp,
SpatialHessianType & sh ) const;
/** Compute the Jacobian of the spatial Jacobian of the transformation. */
virtual void GetJacobianOfSpatialJacobian(
const InputPointType & ipp,
JacobianOfSpatialJacobianType & jsj,
NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
/** Compute both the spatial Jacobian and the Jacobian of the
* spatial Jacobian of the transformation.
*/
virtual void GetJacobianOfSpatialJacobian(
const InputPointType & ipp,
SpatialJacobianType & sj,
JacobianOfSpatialJacobianType & jsj,
NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
/** Compute the Jacobian of the spatial Hessian of the transformation. */
virtual void GetJacobianOfSpatialHessian(
const InputPointType & ipp,
JacobianOfSpatialHessianType & jsh,
NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
/** Compute both the spatial Hessian and the Jacobian of the
* spatial Hessian of the transformation.
*/
virtual void GetJacobianOfSpatialHessian(
const InputPointType & ipp,
SpatialHessianType & sh,
JacobianOfSpatialHessianType & jsh,
NonZeroJacobianIndicesType & nonZeroJacobianIndices ) const;
protected:
/** Print contents of an AdvancedBSplineDeformableTransform. */
virtual void PrintSelf( std::ostream &os, Indent indent ) const;
AdvancedBSplineDeformableTransform();
virtual ~AdvancedBSplineDeformableTransform();
/** Allow subclasses to access and manipulate the weights function. */
// Why??
itkSetObjectMacro( WeightsFunction, WeightsFunctionType );
itkGetObjectMacro( WeightsFunction, WeightsFunctionType );
/** Wrap flat array into images of coefficients. */
void WrapAsImages( void );
virtual void ComputeNonZeroJacobianIndices(
NonZeroJacobianIndicesType & nonZeroJacobianIndices,
const RegionType & supportRegion ) const;
typedef typename Superclass::JacobianImageType JacobianImageType;
typedef typename Superclass::JacobianPixelType JacobianPixelType;
/** Pointer to function used to compute B-spline interpolation weights.
* For each direction we create a different weights function for thread-
* safety.
*/
typename WeightsFunctionType::Pointer m_WeightsFunction;
std::vector<
typename DerivativeWeightsFunctionType::Pointer > m_DerivativeWeightsFunctions;
std::vector< std::vector<
typename SODerivativeWeightsFunctionType::Pointer > > m_SODerivativeWeightsFunctions;
private:
AdvancedBSplineDeformableTransform(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
}; //class AdvancedBSplineDeformableTransform
} // namespace itk
// Define instantiation macro for this template.
#define ITK_TEMPLATE_AdvancedBSplineDeformableTransform(_, EXPORT, x, y) namespace itk { \
_(3(class EXPORT AdvancedBSplineDeformableTransform< ITK_TEMPLATE_3 x >)) \
namespace Templates { typedef AdvancedBSplineDeformableTransform< ITK_TEMPLATE_3 x > \
AdvancedBSplineDeformableTransform##y; } \
}
#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkAdvancedBSplineDeformableTransform+-.h"
#endif
#if ITK_TEMPLATE_TXX
# include "itkAdvancedBSplineDeformableTransform.txx"
#endif
#endif /* __itkAdvancedBSplineDeformableTransform_h */
| [
"[email protected]"
] | [
[
[
1,
363
]
]
] |
427aa0c5c1fdba603165a7cbc99aae653c511f91 | 38664d844d9fad34e88160f6ebf86c043db9f1c5 | /branches/initialize/skin/Samples/Skinmagic Toolkit 2.4/MFC/TransparentDemo/TransparentDemoDlg.h | 97d17761bb3221d489a38ee7ae1a014e344f4342 | [] | no_license | cnsuhao/jezzitest | 84074b938b3e06ae820842dac62dae116d5fdaba | 9b5f6cf40750511350e5456349ead8346cabb56e | refs/heads/master | 2021-05-28T23:08:59.663581 | 2010-11-25T13:44:57 | 2010-11-25T13:44:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,728 | h | // TransparentDemoDlg.h : header file
//
#if !defined(AFX_TRANSPARENTDEMODLG_H__FA117D76_C072_4A2D_BE1A_5374B6792C26__INCLUDED_)
#define AFX_TRANSPARENTDEMODLG_H__FA117D76_C072_4A2D_BE1A_5374B6792C26__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CTransparentDemoDlg dialog
class CTransparentDemoDlg : public CDialog
{
// Construction
public:
CTransparentDemoDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CTransparentDemoDlg)
enum { IDD = IDD_TRANSPARENTDEMO_DIALOG };
CAnimateCtrl m_ctrlAnimate;
CTabCtrl m_TabCtrl;
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CTransparentDemoDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
afx_msg void OnContextMenu(CWnd*, CPoint point);
HIMAGELIST m_hMenuImage;
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CTransparentDemoDlg)
virtual BOOL OnInitDialog();
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnFileExit();
afx_msg void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct);
afx_msg void OnTimer(UINT nIDEvent);
afx_msg void OnDestroy();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
public:
afx_msg void OnBnClickedOk();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_TRANSPARENTDEMODLG_H__FA117D76_C072_4A2D_BE1A_5374B6792C26__INCLUDED_)
| [
"zhongzeng@ba8f1dc9-3c1c-0410-9eed-0f8a660c14bd"
] | [
[
[
1,
58
]
]
] |
357bd923b4d4eead92654edddd0ee757fb11759f | 60365cfb5278ec1dfcc07a5b3e07f3c9d680fa2a | /xlview/Image.cpp | e9a0d21915b316dd7d4c0fe623dc438f312ab57d | [] | no_license | cyberscorpio/xlview | 6c01e96dbf225cfbc2be1cc15a8b70c61976eb46 | a4b5088ce049695de2ed7ed191162e6034326381 | refs/heads/master | 2021-01-01T16:34:47.787022 | 2011-04-28T13:34:25 | 2011-04-28T13:34:25 | 38,444,399 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,849 | cpp | #include <assert.h>
#include <setjmp.h>
#include <process.h>
#include "libxl/include/fs.h"
#include "libxl/include/utilities.h"
#include "ImageConfig.h"
#include "Image.h"
#include "ImageLoader.h"
//////////////////////////////////////////////////////////////////////////
// CImage::BitmapAndDelay
CImage::Frame::Frame () {
delay = DELAY_INFINITE;
}
CImage::Frame::~Frame () {
delay = DELAY_INFINITE;
}
//////////////////////////////////////////////////////////////////////////
// CImage
CImage::CImage () : m_width(-1), m_height(-1) {
//XLTRACE(_T("CImage(0x%08x) created by thread(%d)\n"), this, ::GetCurrentThreadId());
}
CImage::~CImage () {
//XLTRACE(_T("CImage(0x%08x) destroyed by thread(%d)\n"), this, ::GetCurrentThreadId());
}
void CImage::operator = (const CImage &image) {
clear();
m_width = image.m_width;
m_height = image.m_height;
for (size_t i = 0; i < image.m_frames.size(); ++ i) {
_FramePtr bad(new Frame());
bad->bitmap = image.m_frames[i]->bitmap->clone();
bad->delay = image.m_frames[i]->delay;
m_frames.push_back(bad);
}
}
CImagePtr CImage::clone () {
CImage *pImage = new CImage();
CImagePtr image(pImage);
*pImage = *this; // call operator = ()
return image;
}
void CImage::clear () {
m_height = m_width = -1;
m_frames.clear();
}
xl::uint CImage::getImageCount () const {
return m_frames.size();
}
xl::uint CImage::getImageDelay (xl::uint index) const {
assert(index < getImageCount());
return m_frames[index]->delay;
}
xl::ui::CDIBSectionPtr CImage::getImage (xl::uint index) {
assert(index < getImageCount());
return m_frames[index]->bitmap;
}
void CImage::insertImage (xl::ui::CDIBSectionPtr bitmap, xl::uint delay) {
assert(bitmap != NULL);
if (m_width != -1 || m_height != -1) {
assert(m_width == bitmap->getWidth() && m_height == bitmap->getHeight());
} else {
m_width = bitmap->getWidth();
m_height = bitmap->getHeight();
}
_FramePtr bad(new Frame());
bad->bitmap = bitmap;
bad->delay = delay;
m_frames.push_back(bad);
}
CImagePtr CImage::resize (int width, int height, bool highQuality, xl::ILongTimeRunCallback *pCallback) {
if (width == m_width && height == m_height) {
return clone();
} else {
assert(width > 0 && height > 0);
CImage *pImage = new CImage();
CImagePtr image(pImage);
pImage->m_width = width;
pImage->m_height = height;
xl::ui::CDIBSection::RESIZE_TYPE rt_hq = xl::ui::CDIBSection::RT_BOX;
double ratio = (double)width / (double)m_width;
if (ratio > 0.33) {
rt_hq = xl::ui::CDIBSection::RT_BICUBIC;
}
xl::ui::CDIBSection::RESIZE_TYPE rt = highQuality ? rt_hq : xl::ui::CDIBSection::RT_FAST;
for (size_t i = 0; i < m_frames.size(); ++ i) {
xl::ui::CDIBSectionPtr src = m_frames[i]->bitmap;
xl::ui::CDIBSectionPtr dib = xl::ui::CDIBSection::createDIBSection(width, height, src->getBitCounts(), false);
if (!dib) {
return CImagePtr();
}
if (!src->resize(dib.get(), rt, pCallback)) {
assert(pCallback && pCallback->shouldStop());
return CImagePtr();
}
pImage->insertImage(dib, m_frames[i]->delay);
}
return image;
}
}
CSize CImage::getSuitableSize (CSize szArea, CSize szImage, bool dontEnlarge) {
CSize sz(1, 1);
if (szArea.cx * szArea.cy <= 0 || szImage.cx * szImage.cy <= 0) {
} else if (szArea.cx >= szImage.cx && szArea.cy >= szImage.cy && dontEnlarge) {
sz.cx = szImage.cx;
sz.cy = szImage.cy;
} else if ((szArea.cx * szImage.cy) > (szImage.cx * szArea.cy)) {
sz.cx = szImage.cx * szArea.cy / szImage.cy;
sz.cy = szArea.cy;
} else {
sz.cx = szArea.cx;
sz.cy = szImage.cy * szArea.cx / szImage.cx;
}
if (sz.cx <= 0) {
sz.cx = 1;
}
if (sz.cy <= 0) {
sz.cy = 1;
}
return sz;
}
| [
"[email protected]"
] | [
[
[
1,
152
]
]
] |
3457ade4ca80cbc87226ff262ea68cfc10c0ac88 | 28aa891f07cc2240c771b5fb6130b1f4025ddc84 | /clpbr/clpbr/progressive_photon_map_renderer.cpp | 06d0933529a85a301181b0fbffb05eeaca3a4f1a | [] | no_license | Hincoin/mid-autumn | e7476d8c9826db1cc775028573fc01ab3effa8fe | 5271496fb820f8ab1d613a1c2355504251997fef | refs/heads/master | 2021-01-10T19:17:01.479703 | 2011-12-19T14:32:51 | 2011-12-19T14:32:51 | 34,730,620 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,290 | cpp | #include <cmath>
#include <iterator>
#include <omp.h>
#include <CL/cl.hpp>
#include <fstream>
#include "config.h"
#include "progressive_photon_map_renderer.h"
#include "ray_buffer.h"
#include "photon_map.h"
#include "film.h"
#include "camera.h"
#include "random_number_generator_mt19937.h"
#include "scene_data.h"
#include <ctime>
static cl::Context ray_tracing_context_;
static cl::Program ray_tracing_program_;
static std::vector<cl::Device> ray_tracing_devices_;
static cl::CommandQueue ray_tracing_command_queue_;
static cl::Kernel ray_tracing_kernel_;
static cl::Buffer ray_tracing_light_data;
static cl::Buffer ray_tracing_material_data;
static cl::Buffer ray_tracing_shape_data;
static cl::Buffer ray_tracing_texture_data;
static cl::Buffer ray_tracing_accelerator_data;
static cl::Buffer ray_tracing_primitives;
static cl::Buffer ray_tracing_lghts;
static cl::Buffer ray_tracing_colors;
static cl::Buffer ray_tracing_seeds;
static cl::Buffer ray_tracing_rays;
static cl::Context photon_intersect_context_;
static cl::Program photon_intersect_program_;
static std::vector<cl::Device> photon_intersect_devices_;
static cl::CommandQueue photon_intersect_command_queue_;
static cl::Kernel photon_intersect_kernel_;
static cl::Buffer photon_intersect_light_data;
static cl::Buffer photon_intersect_material_data;
static cl::Buffer photon_intersect_shape_data;
static cl::Buffer photon_intersect_texture_data;
static cl::Buffer photon_intersect_accelerator_data;
static cl::Buffer photon_intersect_primitives;
static cl::Buffer photon_intersect_lghts;
static cl::Buffer photon_intersect_lights_power;
static cl::Buffer photon_intersect_light_cdf;
static cl::Buffer photon_intersect_halton;
static cl::Context photon_generate_context_;
static cl::Program photon_generate_program_;
static std::vector<cl::Device> photon_generate_devices_;
static cl::CommandQueue photon_generate_command_queue_;
static cl::Kernel photon_generate_kernel_;
static cl::Buffer photon_generate_light_data;
static cl::Buffer photon_generate_material_data;
static cl::Buffer photon_generate_shape_data;
static cl::Buffer photon_generate_texture_data;
static cl::Buffer photon_generate_accelerator_data;
static cl::Buffer photon_generate_primitives;
static cl::Buffer photon_generate_lghts;
static cl::Buffer photon_generate_photons;
void ReadSource(const char *filename, std::string *source_string)
{
size_t size;
char* str;
std::fstream f(filename, (std::fstream::in | std::fstream::binary));
if(f.is_open())
{
std::streamsize fileSize;
f.seekg(0, std::fstream::end);
size = fileSize = f.tellg();
f.seekg(0, std::fstream::beg);
str = new char[size+1];
if(!str)
{
f.close();
return ;
}
f.read(str, fileSize);
f.close();
str[size] = '\0';
*source_string = str;
delete[] str;
}
else
{
//std::cout << "\nFile containg the kernel code(\".cl\") not found. Please copy the required file in the folder containg the executable.\n";
}
}
PPMRenderer::PPMRenderer(Camera* c,Film* im,Sampler* s,photon_map_t* photon_map)
:camera_(c),image_(im),sampler_(s),photon_map_(photon_map)
{
std::vector<cl::Platform> platforms;
cl::Platform::get(&platforms);
cl_context_properties cprops[]={
CL_CONTEXT_PLATFORM,
(cl_context_properties)(platforms[1])(),
0
};
photon_intersect_context_ = cl::Context(CL_DEVICE_TYPE_CPU, cprops);
photon_intersect_devices_ = photon_intersect_context_.getInfo<CL_CONTEXT_DEVICES>();
photon_intersect_command_queue_ = cl::CommandQueue(photon_intersect_context_,photon_intersect_devices_[0],0);
cl_context_properties cpu_cprops[]={
CL_CONTEXT_PLATFORM,
(cl_context_properties)(platforms[0])(),
0
};
ray_tracing_context_ = cl::Context(CL_DEVICE_TYPE_CPU,cpu_cprops);
ray_tracing_devices_ = ray_tracing_context_.getInfo<CL_CONTEXT_DEVICES>();
ray_tracing_command_queue_ = cl::CommandQueue(ray_tracing_context_,ray_tracing_devices_[0],0);
photon_generate_context_ = photon_intersect_context_;//cl::Context(CL_DEVICE_TYPE_GPU, cprops);
photon_generate_devices_ = photon_generate_context_.getInfo<CL_CONTEXT_DEVICES>();
photon_generate_command_queue_ = cl::CommandQueue(photon_generate_context_,photon_generate_devices_[0],0);
std::string source_string;
ReadSource("intersect_kernel.cl",&source_string);
cl::Program::Sources photon_intersect_sources(1,std::make_pair(source_string.c_str(),0));
photon_intersect_program_ = cl::Program(photon_intersect_context_,photon_intersect_sources);
photon_intersect_program_.build(photon_intersect_devices_,"-I. ");
photon_intersect_kernel_ = cl::Kernel(photon_intersect_program_,"photon_intersect");
source_string.clear();
ReadSource("rendering_kernel.cl",&source_string);
cl::Program::Sources ray_tracing_sources(1,std::make_pair(source_string.c_str(),0));
ray_tracing_program_ = cl::Program(ray_tracing_context_,ray_tracing_sources);
ray_tracing_program_.build(ray_tracing_devices_,"-I. ");
ray_tracing_kernel_ = cl::Kernel(ray_tracing_program_,"render");
source_string.clear();
ReadSource("photon_generation.cl",&source_string);
cl::Program::Sources photon_generate_sources(1,std::make_pair(source_string.c_str(),0));
photon_generate_program_ = cl::Program(photon_generate_context_,photon_generate_sources);
photon_generate_program_.build(photon_generate_devices_,"-I. ");
photon_generate_kernel_ = cl::Kernel(photon_generate_program_,"photon_generation");
}
PPMRenderer::~PPMRenderer()
{
delete camera_;
delete sampler_;
delete image_;
}
template<typename T>
cl::Buffer CreateBuffer(cl::Context context, cl_mem_flags flag, const std::vector<T>& data)
{
return cl::Buffer(context,flag | CL_MEM_COPY_HOST_PTR,sizeof(T) * data.size(),(void*)&data[0]);
}
void PPMRenderer::InitializeDeviceData(const scene_info_memory_t& scene_info)
{
ray_tracing_light_data = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY,scene_info.light_data);
ray_tracing_material_data = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.material_data);
ray_tracing_shape_data = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.shape_data);
ray_tracing_texture_data= CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.texture_data);
ray_tracing_accelerator_data = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.accelerator_data);
ray_tracing_primitives = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.primitives);
ray_tracing_lghts = CreateBuffer(ray_tracing_context_, CL_MEM_READ_ONLY, scene_info.lghts);
ray_tracing_kernel_.setArg(2,ray_tracing_light_data);
ray_tracing_kernel_.setArg(3,ray_tracing_material_data);
ray_tracing_kernel_.setArg(4,ray_tracing_shape_data);
ray_tracing_kernel_.setArg(5,ray_tracing_texture_data);
//ray_tracing_kernel_.setArg(6,ray_tracing_integrator_data);
ray_tracing_kernel_.setArg(7,ray_tracing_accelerator_data);
ray_tracing_kernel_.setArg(8,ray_tracing_primitives);
ray_tracing_kernel_.setArg(9,ray_tracing_lghts);
ray_tracing_kernel_.setArg(11,(unsigned int)scene_info.primitives.size());
ray_tracing_kernel_.setArg(12,(unsigned int)scene_info.lghts.size());
photon_generate_light_data = photon_intersect_light_data = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY,scene_info.light_data);
photon_generate_material_data = photon_intersect_material_data = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.material_data);
photon_generate_shape_data = photon_intersect_shape_data = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.shape_data);
photon_generate_texture_data = photon_intersect_texture_data= CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.texture_data);
photon_generate_accelerator_data = photon_intersect_accelerator_data = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.accelerator_data);
photon_generate_primitives = photon_intersect_primitives = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.primitives);
photon_generate_lghts = photon_intersect_lghts = CreateBuffer(photon_intersect_context_, CL_MEM_READ_ONLY, scene_info.lghts);
photon_intersect_kernel_.setArg(2,photon_intersect_light_data);
photon_intersect_kernel_.setArg(3,photon_intersect_material_data);
photon_intersect_kernel_.setArg(4,photon_intersect_shape_data);
photon_intersect_kernel_.setArg(5,photon_intersect_texture_data);
photon_intersect_kernel_.setArg(6,photon_intersect_accelerator_data);
photon_intersect_kernel_.setArg(7,photon_intersect_primitives);
photon_intersect_kernel_.setArg(8,photon_intersect_lghts);
photon_intersect_kernel_.setArg(13,(unsigned int)scene_info.primitives.size());
photon_intersect_kernel_.setArg(14,(unsigned int)scene_info.lghts.size());
photon_generate_kernel_.setArg(2,photon_generate_light_data);
photon_generate_kernel_.setArg(3,photon_generate_material_data);
photon_generate_kernel_.setArg(4,photon_generate_shape_data);
photon_generate_kernel_.setArg(5,photon_generate_texture_data);
photon_generate_kernel_.setArg(6,photon_generate_accelerator_data);
photon_generate_kernel_.setArg(7,photon_generate_primitives);
photon_generate_kernel_.setArg(8,photon_generate_lghts);
photon_generate_kernel_.setArg(10,(unsigned int)scene_info.primitives.size());
photon_generate_kernel_.setArg(11,(unsigned int)scene_info.lghts.size());
}
static std::vector<float> as_float_array(const photon_kd_tree_t& photon_kd_tree)
{
float pad = 0.f;
std::vector<float> v;
v.push_back(as_float(photon_kd_tree.n_nodes));
v.push_back(as_float(photon_kd_tree.next_free_node));
v.push_back(pad);
v.push_back(pad);
for (unsigned int i = 0;i < photon_kd_tree.n_nodes; ++i)
{
v.push_back((photon_kd_tree.nodes[i].split_pos));
v.push_back(as_float(photon_kd_tree.nodes[i].data));
}
size_t n = v.size();
if (n%4)
{
for(unsigned int i = 0;i < (4-(n % 4));++i)
{
v.push_back(pad);//pad
}
}
for(unsigned int i = 0;i < photon_kd_tree.n_nodes; ++i)
{
save_float3(v,photon_kd_tree.node_data[i].p);
save_float3(v,photon_kd_tree.node_data[i].alpha);
save_float3(v,photon_kd_tree.node_data[i].wi);
}
n = v.size();
if (n%4)
for(unsigned int i = 0;i < (4-(n % 4));++i)
{
v.push_back(pad);//pad
}
return v;
}
static std::vector<float> as_float_array(const radiance_photon_kd_tree_t& photon_kd_tree)
{
//
std::vector<float> v;
v.push_back(as_float(photon_kd_tree.n_nodes));
v.push_back(as_float(photon_kd_tree.next_free_node));
float pad = 0.f;
v.push_back(pad);
v.push_back(pad);
for (unsigned int i = 0;i < photon_kd_tree.n_nodes; ++i)
{
v.push_back((photon_kd_tree.nodes[i].split_pos));
v.push_back(as_float(photon_kd_tree.nodes[i].data));
}
size_t n = v.size();
if(n%4)
for(unsigned int i = 0;i < (4-(n % 4));++i)
{
v.push_back(pad);//pad
}
for(unsigned int i = 0;i < photon_kd_tree.n_nodes; ++i)
{
save_float3(v,photon_kd_tree.node_data[i].p);
save_float3(v,photon_kd_tree.node_data[i].n);
save_float3(v,photon_kd_tree.node_data[i].lo);
}
n = v.size();
if(n%4)
for(unsigned int i = 0;i < (4-(n % 4));++i)
{
v.push_back(pad);//pad
}
return v;
}
static std::vector<float> as_float_array(const photon_map_t& photon_map)
{
std::vector<float> v;
v.push_back(as_float(photon_map.n_caustic_photons));
v.push_back(as_float(photon_map.n_indirect_photons));
v.push_back(as_float(photon_map.n_lookup));
v.push_back(as_float(photon_map.max_specular_depth));
v.push_back(as_float(photon_map.max_dist_squared));
v.push_back(as_float(photon_map.rr_threshold));
v.push_back(as_float(photon_map.n_caustic_paths));
v.push_back(as_float(photon_map.n_indirect_paths));
// Declare sample parameters for light source sampling
std::vector<float> caustic_array = as_float_array(photon_map.caustic_map);
std::vector<float> indirect_array = as_float_array(photon_map.indirect_map);
std::vector<float> radiance_array = as_float_array(photon_map.radiance_map);
std::copy(caustic_array.begin(),caustic_array.end(),std::back_inserter(v));
std::copy(indirect_array.begin(),indirect_array.end(),std::back_inserter(v));
std::copy(radiance_array.begin(),radiance_array.end(),std::back_inserter(v));
v.push_back(as_float(photon_map.total_photons));
v.push_back(as_float(photon_map.final_gather));
v.push_back(as_float(photon_map.cos_gather_angle));
v.push_back(as_float(photon_map.gather_samples));
v.push_back(as_float(photon_map.progressive_iteration));
v.push_back(as_float(photon_map.alpha));
return v;
}
void PPMRenderer::Render(const scene_info_memory_t& scene_info_mem)
{
RandomNumberGeneratorMT19937 *rng = new RandomNumberGeneratorMT19937(rand() << 16 | rand());
scene_info_memory_t scene_info = scene_info_mem;
InitializeDeviceData(scene_info);
const int buffer_size = 1024*1024*2;
std::vector<Seed> seeds;
Seed seed;
for (int i = 0;i < buffer_size; ++i)
{
init_rng(rng->RandomUnsignedInt(),&seed);
seeds.push_back(seed);
}
ray_tracing_seeds = CreateBuffer(ray_tracing_context_,CL_MEM_READ_WRITE,seeds);
ray_tracing_kernel_.setArg(1,ray_tracing_seeds);
size_t ray_tracing_work_group_size;
ray_tracing_kernel_.getWorkGroupInfo(ray_tracing_devices_[0],CL_KERNEL_WORK_GROUP_SIZE,&ray_tracing_work_group_size);
int iteration = 0;
while(true)
{
clock_t t0;
t0 = clock();
sampler_->ResetSamplePosition();
cl_photon_init_device_info_t device_info;
device_info.photon_generate_command_queue = photon_generate_command_queue_;
device_info.photon_generate_context = photon_generate_context_;
device_info.photon_generate_kernel = photon_generate_kernel_;
device_info.photon_intersect_command_queue = photon_intersect_command_queue_;
device_info.photon_intersect_context = photon_intersect_context_;
device_info.photon_intersect_kernel = photon_intersect_kernel_;
photon_map_init(photon_map_,scene_info,*rng, device_info);
scene_info.integrator_data = as_float_array(*photon_map_);
cl::Buffer ray_tracing_integrator_data =
CreateBuffer(ray_tracing_context_,CL_MEM_READ_ONLY,scene_info.integrator_data);
ray_tracing_kernel_.setArg(6,ray_tracing_integrator_data);
bool has_more_sample = true;
sampler_->ResetSamplePosition();
int ray_traced = 0;
while(has_more_sample)//do eye pass
{
std::vector<spectrum_t> local_color_buffer;
std::vector<camera_sample_t> local_samples;//all sample per path
//
std::vector<ray_differential_t> ray_buffer;
ray_buffer.reserve(buffer_size);
camera_sample_t sample;
ray_differential_t ray;
float ray_weight;
while(ray_buffer.size() < buffer_size && has_more_sample)
{
if(sampler_->GetNextSample(&sample))
{
camera_->GenerateRay(sample, &ray, &ray_weight);
ray_buffer.push_back(ray);
local_samples.push_back(sample);
}
else
has_more_sample = false;
}
local_color_buffer.resize(ray_buffer.size(),spectrum_t());
//#define USE_OPENCL
#ifndef USE_OPENCL
photon_map_t loaded_photon_map;
load_photon_map(&loaded_photon_map,&scene_info.integrator_data[0]);
//#pragma omp parallel for schedule(dynamic, 32)
for(unsigned int i = 0;i < ray_buffer.size(); ++i)
{
if(i == 151+ 19 * 256)
{
int xxxxx= 0;
}
LOCAL ray_t ray_stack[MAX_RAY_DEPTH];
LOCAL spectrum_t passthrough[MAX_RAY_DEPTH];
LOCAL bsdf_t bsdf_stack[MAX_RAY_DEPTH];
LOCAL bool left_stack[MAX_RAY_DEPTH];//todo: change to bit
//lphoton data
LOCAL close_photon_t close_photon_data_store[MAX_CLOSE_PHOTON_LOOKUP];
//final gather data
LOCAL close_photon_t photon_buffer[n_indir_sample_photons];
LOCAL vector3f_t photon_dirs [n_indir_sample_photons];
photon_map_li(&loaded_photon_map,&ray_buffer[i],as_cl_scene_info(scene_info),&seeds[i],&local_color_buffer[i],
ray_stack,passthrough,bsdf_stack,left_stack,close_photon_data_store,photon_buffer,photon_dirs
);
image_->AddSample(local_samples[i],local_color_buffer[i]);
}
#else
if(!ray_buffer.empty())
{
cl::Buffer ray_tracing_color_buffer = CreateBuffer(ray_tracing_context_,CL_MEM_READ_WRITE,local_color_buffer);
ray_tracing_kernel_.setArg(0,ray_tracing_color_buffer);
cl::Buffer ray_tracing_ray_buffer = CreateBuffer(ray_tracing_context_,CL_MEM_READ_ONLY,ray_buffer);
ray_tracing_kernel_.setArg(10,ray_tracing_ray_buffer);
ray_tracing_kernel_.setArg(13,(unsigned int) local_color_buffer.size());
printf("sizeof spectrum_t,Seed,ray_diffrential:%d,%d,%d,%d,%d,kd_node:%d \n",
sizeof(spectrum_t),sizeof(Seed),sizeof(ray_differential_t),sizeof(photon_t),sizeof(radiance_photon_t),
sizeof(kd_node_t));
size_t global_threads = ray_buffer.size();
if (global_threads % ray_tracing_work_group_size!= 0)
global_threads = (global_threads / ray_tracing_work_group_size + 1) * ray_tracing_work_group_size;
size_t local_threads = ray_tracing_work_group_size;
ray_tracing_command_queue_.enqueueNDRangeKernel(ray_tracing_kernel_,cl::NullRange,cl::NDRange(global_threads),cl::NDRange(local_threads));
ray_tracing_command_queue_.enqueueReadBuffer(ray_tracing_color_buffer,CL_TRUE,0,
local_color_buffer.size() * sizeof(local_color_buffer[0])
,&local_color_buffer[0]);
//////////////////////////////////////////////////////////////////////////
for(size_t i = 0;i < local_samples.size(); ++i)
image_->AddSample(local_samples[i],local_color_buffer[i]);
ray_traced += ray_buffer.size();
printf("\r%d ray traced...",ray_traced);
}
#endif
}
photon_map_destroy(photon_map_);
if(0 == iteration % 2)
image_->WriteImage(iteration);
iteration ++;
//photon_map_->max_dist_squared = photon_map_->max_dist_squared * (iteration + photon_map_->alpha_)/(iteration + 1);
photon_map_->progressive_iteration = iteration;
printf("iteration:%d total_photons: %d clocks: %ld\n",iteration,photon_map_->total_photons,clock() - t0);
}
delete rng;
} | [
"luozhiyuan@ea6f400c-e855-0410-84ee-31f796524d81"
] | [
[
[
1,
451
]
]
] |
3614dae6d144b7546da167fd11b7ed7a607d52bd | b7b58c5e83ae0e868414e8a6900b92fcfa87b4b1 | /Tools/LZSS/lzssA.cpp | a796e75b536d9102b35f5f02c04615866d3292ce | [] | no_license | dailongao/cheat-fusion | 87df8bd58845f30808600b72167ff6c778a36245 | ab7cd0fe56df0edabb9064da70b93a2856df7fac | refs/heads/master | 2021-01-10T12:42:37.958692 | 2010-12-31T13:42:51 | 2010-12-31T13:42:51 | 51,513,373 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 7,752 | cpp | //压缩率比标准高一点
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <memory.h>
#include <conio.h>
#include <vector>
#include <deque>
#define LOOKAHEAD 1
#define LOOKAHEAD_COMPARE_LEN 5
using namespace std;
#define N 4096 /* size of ring buffer */
#define F 18 /* upper limit for match_length */
#define THRESHOLD 2 /* encode string into position and length
if match_length is greater than this */
#define NIL N /* index for root of binary search trees */
unsigned long int
textsize = 0, /* text size counter */
codesize = 0, /* code size counter */
printcount = 0; /* counter for reporting progress every 1K bytes */
unsigned char
text_buf[N + F - 1]; /* ring buffer of size N,
with extra F-1 bytes to facilitate string comparison */
typedef struct
{
int pos;
int ptr;
int len;
} lz_find;
unsigned char buffer[0x100000];
unsigned int buf_ptr;
unsigned char file_buffer[0x100000];
FILE *infile, *outfile; /* input & output files */
vector<int> table[256];
vector<lz_find> lz_table;
int encode_bytes;
int ptr = 0;
int size = 0;
int min_match = THRESHOLD + 1;
//int window_size = N;
//int max_match = F;
int max_match = 0x0f + 3;
int window_size = 0xfff;
int run_mask = 0x0f;
int win_mask = 0xf0;
int win_bits = 4;
int cache_ptr = 0xfee;
int cache_mask = 0xfff;
void LZInit(unsigned int filesize)
{
int i;
for(i=0;i<256;i++)
table[i].reserve(filesize/128);
lz_table.reserve(filesize/8);
}
void Find_LZ( int start, unsigned char byte, int &length, int &pos )
{
int longest_length = 0;
int longest_ptr = 0;
// use cached positions to quickly look through the file
for( int lcv = 0; lcv < table[ byte ].size(); lcv++ ) {
int match_length = 0;
int ptr = table[ byte ][ lcv ];
// invalid string; stop scanning
if( ptr >= start )
break;
// LZ window restriction
if( start - ptr > window_size )
continue;
// search for longest identical substring
for( int lcv2 = start; ( lcv2 < start + max_match ) && ( lcv2 < size ); lcv2++ ) {
// look for a mismatch
if( buffer[ lcv2 ] != buffer[ ptr ] )
break;
// keep looking
ptr++;
match_length++;
}
// record new long find
if( longest_length <= match_length ) {
longest_ptr = table[ byte ][ lcv ];
longest_length = match_length;
}
}
// output findings
length = longest_length;
pos = longest_ptr;
}
void LZEncode(FILE *in, FILE *out)
{
lz_find lz;
int start;
int lcv;
int count=N-F;
fseek(in,0,SEEK_END);
buf_ptr = ftell(in);
fseek(in,0,SEEK_SET);
fread(file_buffer,1,buf_ptr,in);
//LZInit(buf_ptr);
// Step 1: Find all LZ matches (optimal)
start = 0;
size = buf_ptr;
encode_bytes = 0;
memset( buffer, 0, cache_ptr );
memcpy( buffer + cache_ptr, file_buffer, size );
start += cache_ptr;
size += cache_ptr;
for( lcv = 0; lcv < cache_ptr; lcv++ ) {
table[ 0 ].push_back( lcv );
}
while( start < size ) {
int future_length[10];
int future_pos[10];
int length;
int pos;
// Prepare for LZ
table[ buffer[ start ] ].push_back( start );
// Go find the longest substring match (and future ones)
Find_LZ( start, buffer[ start ], length, pos );
// Slightly increase ratio performance
for( lcv = 0; lcv < LOOKAHEAD; lcv++ ) {
start++; table[ buffer[ start ] ].push_back( start );
Find_LZ( start, buffer[ start ], future_length[ lcv ], future_pos[ lcv ]);
}
// Un-do lookahead
for( lcv = LOOKAHEAD; lcv > 0; lcv-- ) {
table[ buffer[ start ] ].pop_back(); start--;
if(length<LOOKAHEAD_COMPARE_LEN){ //5这个数字可以提高压缩率
if( future_length[ lcv-1 ] - length >= lcv ) length = 0;
}
else{
if( future_length[ lcv-1 ] - length > lcv ) length = 0;
}
}
if( length >= min_match ) {
// Found substring match; record and re-do
lz.pos = start;
lz.ptr = count-(start-pos);
lz.len = length;
//printf("ptr:%x,len:%x;start:%x\n",pos,length,start-cache_ptr);getch();
lz_table.push_back( lz );
// Need to add to LZ table
for( int lcv = 1; lcv < length; lcv++ )
table[ buffer[ start + lcv ] ].push_back( start + lcv );
// Fast update
start += length;
count += length;
encode_bytes += 2;
}
else {
// No substrings found; try again
start++;
count++;
encode_bytes++;
}
count&=N-1;
}
// insert dummy entry
lz.pos = -1;
lz_table.push_back( lz );
start -= cache_ptr;
size -= cache_ptr;
///////////////////////////////////////////////////////////////
int lz_ptr;
int out_byte;
int out_bits;
int out_ptr;
unsigned char out_buffer[0x100];
// init
lz_ptr = 0;
start = 0;
out_ptr = 0;
out_byte = 0;
out_bits = 8;
start += cache_ptr;
size += cache_ptr;
// Step 2: Prepare encoding methods
while( start < size ) {
lz = lz_table[ lz_ptr ];
out_byte >>= 1;
if( lz.pos == start ) {
// LZ
out_byte |= ( 0 << 7 );
int temp = (lz.ptr);
out_buffer[ out_ptr++ ] = temp & 0xff;
out_buffer[ out_ptr ] = ( lz.len - 1 - 2 ) & 0x0f;
out_buffer[ out_ptr++ ] |= ( ( temp & 0xf00 ) >> 8 ) << 4;
start += lz.len;
lz_ptr++;
}
else {
// Free byte
out_byte |= ( 1 << 7 );
out_buffer[ out_ptr++ ] = buffer[ start ];
start++;
}
// flush out data
out_bits--;
if( !out_bits ) {
fputc( out_byte, out );
fwrite( out_buffer, 1, out_ptr, out );
codesize+=out_ptr+1;
out_ptr = 0;
out_byte = 0;
out_bits = 8;
}
} // end method check
// add final LZ bit
out_byte >>= 1;
out_byte |= ( 0 << 7 );
//out_buffer[ out_ptr++ ] = 0;
//out_buffer[ out_ptr++ ] = 0;
out_bits--;
// shove in dummy bits
while( out_bits-- ) out_byte >>= 1;
// flush out data
fputc( out_byte, out );
fwrite( out_buffer, 1, out_ptr, out );
codesize+=out_ptr+1;
}
void Decode(void) /* Just the reverse of Encode(). */
{
int i, j, k, r, c;
unsigned int flags;
for (i = 0; i < N - F; i++) text_buf[i] = 0;
r = N - F; flags = 0;
for ( ; ; ) {
if (((flags >>= 1) & 256) == 0) {
if ((c = getc(infile)) == EOF) break;
flags = c | 0xff00; /* uses higher byte cleverly */
} /* to count eight */
if (flags & 1) {
if ((c = getc(infile)) == EOF) break;
putc(c, outfile); text_buf[r++] = c; r &= (N - 1);
} else {
if ((i = getc(infile)) == EOF) break;
if ((j = getc(infile)) == EOF) break;
i |= ((j & 0xf0) << 4); j = (j & 0x0f) + THRESHOLD;
for (k = 0; k <= j; k++) {
c = text_buf[(i + k) & (N - 1)];
putc(c, outfile); text_buf[r++] = c; r &= (N - 1);
}
}
}
}
int main(int argc, char *argv[])
{
char *s;
time_t t_start,t_finish;
if (argc != 4) {
printf("'lzss e file1 file2' encodes file1 into file2.\n"
"'lzss d file2 file1' decodes file2 into file1.\n");
return EXIT_FAILURE;
}
if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
|| (s = argv[2], (infile = fopen(s, "rb")) == NULL)
|| (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
printf("??? %s\n", s); return EXIT_FAILURE;
}
t_start=time(NULL);
if (toupper(*argv[1]) == 'E') {
fwrite(&codesize,1,4,outfile);
LZEncode(infile, outfile);
fseek(outfile,0,SEEK_SET);
codesize+=4;
fwrite(&codesize,1,4,outfile);
}
else {
fseek(infile,4,SEEK_SET);
Decode();
}
t_finish=time(NULL);
fclose(infile); fclose(outfile);
printf("%f Secs\n",difftime(t_finish,t_start)) ;
return EXIT_SUCCESS;
}
| [
"forbbsneo@1e91e87a-c719-11dd-86c2-0f8696b7b6f9"
] | [
[
[
1,
338
]
]
] |
8f944201044f9c05f262afc79669138ee441ac36 | 3e69b159d352a57a48bc483cb8ca802b49679d65 | /tags/release-2006-04-24/eeschema/onleftclick.cpp | e45c8a520358d21822ef2623a59fd733a5c7bf97 | [] | no_license | BackupTheBerlios/kicad-svn | 4b79bc0af39d6e5cb0f07556eb781a83e8a464b9 | 4c97bbde4b1b12ec5616a57c17298c77a9790398 | refs/heads/master | 2021-01-01T19:38:40.000652 | 2006-06-19T20:01:24 | 2006-06-19T20:01:24 | 40,799,911 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 9,561 | cpp | /******************************************************/
/* schedit.cpp: fonctions generales de la schematique */
/******************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"
#include "general.h"
#include "id.h"
#include "protos.h"
static wxArrayString s_CmpNameList;
static wxArrayString s_PowerNameList;
/**********************************************************************************/
void WinEDA_SchematicFrame::OnLeftClick(wxDC * DC, const wxPoint& MousePos)
/**********************************************************************************/
/* Traite les commandes declenchée par le bouton gauche de la souris,
quand un outil est deja selectionné
*/
{
EDA_BaseStruct * DrawStruct = m_CurrentScreen->m_CurrentItem;
if ( (m_ID_current_state == 0) || ( DrawStruct && DrawStruct->m_Flags ) )
{
DrawPanel->m_AutoPAN_Request = FALSE;
g_ItemToRepeat = NULL;
if ( DrawStruct && DrawStruct->m_Flags ) // Commande "POPUP" en cours
{
switch (DrawStruct->m_StructType )
{
case DRAW_SHEETLABEL_STRUCT_TYPE:
case DRAW_SHEET_STRUCT_TYPE:
case DRAW_BUSENTRY_STRUCT_TYPE:
case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE:
case DRAW_JUNCTION_STRUCT_TYPE:
case DRAW_LIB_ITEM_STRUCT_TYPE:
case DRAW_PART_TEXT_STRUCT_TYPE:
DrawStruct->Place( this, DC);
m_CurrentScreen->m_CurrentItem = NULL;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
return;
case SCREEN_STRUCT_TYPE:
case DRAW_PICK_ITEM_STRUCT_TYPE:
DisplayError(this,
wxT("OnLeftClick err: unexpected type for Place"));
DrawStruct->m_Flags = 0;
break;
case DRAW_SEGMENT_STRUCT_TYPE: // Segment peut-etre en cours de trace
break;
default:
DisplayError(this,
wxT("WinEDA_SchematicFrame::OnLeftClick err: m_Flags != 0"));
DrawStruct->m_Flags = 0;
break;
}
}
else
{
DrawStruct = SchematicGeneralLocateAndDisplay();
}
}
switch ( m_ID_current_state )
{
case 0:
break;
case ID_NO_SELECT_BUTT:
break;
case ID_HIERARCHY_PUSH_POP_BUTT:
if ( DrawStruct && DrawStruct->m_Flags ) break;
DrawStruct = SchematicGeneralLocateAndDisplay();
if ( DrawStruct && (DrawStruct->m_StructType == DRAW_SHEET_STRUCT_TYPE) )
{
InstallNextScreen((DrawSheetStruct *) DrawStruct);
}
else InstallPreviousScreen();
break;
case ID_NOCONN_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
g_ItemToRepeat = CreateNewNoConnectStruct(DC);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place(this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
}
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
break;
case ID_JUNCTION_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem = g_ItemToRepeat
= CreateNewJunctionStruct(DC, m_CurrentScreen->m_Curseur);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place(this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
}
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
break;
case ID_WIRETOBUS_ENTRY_BUTT:
case ID_BUSTOBUS_ENTRY_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
DrawStruct =
CreateBusEntry(DC,
(m_ID_current_state == ID_WIRETOBUS_ENTRY_BUTT) ?
WIRE_TO_BUS : BUS_TO_BUS);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place(this, DC);
m_CurrentScreen->m_CurrentItem = NULL;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
}
break;
case ID_SCHEMATIC_DELETE_ITEM_BUTT:
LocateAndDeleteItem(this, DC);
m_CurrentScreen->SetModify();
m_CurrentScreen->m_CurrentItem = NULL;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
break;
case ID_WIRE_BUTT:
BeginSegment(DC, LAYER_WIRE);
DrawPanel->m_AutoPAN_Request = TRUE;
break;
case ID_BUS_BUTT:
BeginSegment(DC, LAYER_BUS);
DrawPanel->m_AutoPAN_Request = TRUE;
break;
case ID_LINE_COMMENT_BUTT:
BeginSegment(DC, LAYER_NOTES);
DrawPanel->m_AutoPAN_Request = TRUE;
break;
case ID_TEXT_COMMENT_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
CreateNewText(DC, LAYER_NOTES);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place(this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
}
break;
case ID_LABEL_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
CreateNewText(DC, LAYER_LOCLABEL);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place( this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
case ID_GLABEL_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
CreateNewText(DC, LAYER_GLOBLABEL);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place(this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
case ID_SHEET_SYMBOL_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem = CreateSheet(DC);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place( this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
case ID_IMPORT_GLABEL_BUTT:
case ID_SHEET_LABEL_BUTT:
if( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
DrawStruct = SchematicGeneralLocateAndDisplay();
if ( DrawStruct == NULL) break;
if( (DrawStruct->m_StructType == DRAW_SHEET_STRUCT_TYPE) &&
(DrawStruct->m_Flags == 0) )
{
if ( m_ID_current_state == ID_IMPORT_GLABEL_BUTT )
m_CurrentScreen->m_CurrentItem =
Import_PinSheet( (DrawSheetStruct *) DrawStruct, DC);
else
m_CurrentScreen->m_CurrentItem =
Create_PinSheet( (DrawSheetStruct *) DrawStruct, DC);
}
else if( (DrawStruct->m_StructType == DRAW_SHEETLABEL_STRUCT_TYPE) &&
(DrawStruct->m_Flags != 0) )
{
DrawStruct->Place(this, DC);
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
case ID_COMPONENT_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem = Load_Component(DC, wxEmptyString,
s_CmpNameList, TRUE);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place( this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
case ID_PLACE_POWER_BUTT:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
m_CurrentScreen->m_CurrentItem =
Load_Component(DC, wxT("power"),s_PowerNameList, FALSE);
DrawPanel->m_AutoPAN_Request = TRUE;
}
else
{
DrawStruct->Place( this, DC);
DrawPanel->m_AutoPAN_Request = FALSE;
TestDanglingEnds(m_CurrentScreen->EEDrawList, DC);
}
break;
default :
{
SetToolID( 0, wxCURSOR_ARROW, wxEmptyString);
wxString msg( wxT("WinEDA_SchematicFrame::OnLeftClick error state "));
msg << m_ID_current_state;
DisplayError(this, msg);
break;
}
}
}
/***************************************************************************/
void WinEDA_SchematicFrame::OnLeftDClick(wxDC * DC, const wxPoint& MousePos)
/***************************************************************************/
/* Appelé sur un double click:
pour un élément editable (textes, composant):
appel de l'editeur correspondant.
pour une connexion en cours:
termine la connexion
*/
{
EDA_BaseStruct * DrawStruct = m_CurrentScreen->m_CurrentItem;
wxPoint pos = GetPosition();
switch ( m_ID_current_state )
{
case 0:
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags == 0) )
{
DrawStruct = SchematicGeneralLocateAndDisplay();
}
if ( (DrawStruct == NULL) || (DrawStruct->m_Flags != 0) )
break;
// Element localisé
switch ( DrawStruct->m_StructType )
{
case DRAW_SHEET_STRUCT_TYPE:
InstallNextScreen((DrawSheetStruct *) DrawStruct);
break;
case DRAW_LIB_ITEM_STRUCT_TYPE:
InstallCmpeditFrame(this, pos, (EDA_SchComponentStruct *) DrawStruct);
DrawPanel->MouseToCursorSchema();
break;
case DRAW_TEXT_STRUCT_TYPE:
case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
EditSchematicText( (DrawTextStruct*)DrawStruct, DC);
break;
case DRAW_PART_TEXT_STRUCT_TYPE:
EditCmpFieldText( (PartTextStruct *)DrawStruct, DC);
DrawPanel->MouseToCursorSchema();
break;
default:
break;
}
break; // end case 0
case ID_BUS_BUTT:
case ID_WIRE_BUTT:
case ID_LINE_COMMENT_BUTT:
if ( DrawStruct && (DrawStruct->m_Flags & IS_NEW) )
EndSegment(DC);
break;
}
}
| [
"fcoiffie@244deca0-f506-0410-ab94-f4f3571dea26"
] | [
[
[
1,
351
]
]
] |
5f6058d19c9ef8eaf3408f884a91bfa08ff4c651 | 8a3fce9fb893696b8e408703b62fa452feec65c5 | /业余时间学习笔记/IOCP/IOServer/IOServer/stdafx.cpp | 280639ccba0d2732be600ad255e104d76e143b0c | [] | no_license | win18216001/tpgame | bb4e8b1a2f19b92ecce14a7477ce30a470faecda | d877dd51a924f1d628959c5ab638c34a671b39b2 | refs/heads/master | 2021-04-12T04:51:47.882699 | 2011-03-08T10:04:55 | 2011-03-08T10:04:55 | 42,728,291 | 0 | 2 | null | null | null | null | GB18030 | C++ | false | false | 268 | cpp | // stdafx.cpp : 只包括标准包含文件的源文件
// IOServer.pch 将作为预编译头
// stdafx.obj 将包含预编译类型信息
#include "stdafx.h"
// TODO: 在 STDAFX.H 中
// 引用任何所需的附加头文件，而不是在此文件中引用
| [
"[email protected]"
] | [
[
[
1,
8
]
]
] |
390e18dd63ef61a27c586d308a25573b3e91cc00 | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/Game/wheel/NetWheelDirector/include/Logic/SetWinMsg.h | 2895b8fe71a0c2e5a0393af5e16b5f8e68cc0a36 | [] | no_license | dbabox/aomi | dbfb46c1c9417a8078ec9a516cc9c90fe3773b78 | 4cffc8e59368e82aed997fe0f4dcbd7df626d1d0 | refs/heads/master | 2021-01-13T14:05:10.813348 | 2011-06-07T09:36:41 | 2011-06-07T09:36:41 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 3,516 | h | #ifndef __Orz_SetWinMsgA_h__
#define __Orz_SetWinMsgA_h__
#include "WheelLogic.h"
#include "StartLogic.h"
#include "WMHardwareInterface.h"
#include "WinData.h"
#include "LockInterface.h"
#include "DataServerInterface.h"
namespace Orz
{
////ÉèÖÃÓ²¼þÊôÐÔ
//class SetWinMsg
//{
//public:
///* TimeType getWaitTime(void) const
// {
// return 0.0f;
// }*/
// SetWinMsg(void):/*_allScore(0),*/_communicate(NULL)/*,_lock(NULL),_dataServer(NULL)*/
// {
// Orz::ComponentPtr scoreComp = Orz::ComponentFactories::getInstance().create("Score");
// ScoreInterface * score = scoreComp->queryInterface<ScoreInterface>();
// score->calculator();
// const ScoreInterface::ScoreResult & result = score->getResult();
// _prototype = result.prototype;
// WinData::getInstance().clear();
// WinData::getInstance().setTable(result.table);
// WinData::getInstance().setWinner(result.winner);
//
// if(result.bonus.has && _prototype->winMode == WheelEnum::NONE)
// {
// WinData::getInstance().setWinMode(WheelEnum::GOLD);
// }else
// {
// WinData::getInstance().setWinMode(_prototype->winMode);
// }
//
// WinData::getInstance().setBonus(result.bonus.has, result.bonus.bonus, result.bonus.invest, result.bonus.profitForPerInvest);
// Orz::ComponentPtr dataComp = Orz::ComponentFactories::getInstance().create("DataCentre");
// Orz::DataCentreInterface * data = dataComp->queryInterface<DataCentreInterface>();
// BOOST_FOREACH(WheelEnum::AnimalItem item , _prototype->animalItems)
// {
// int id = data->item2Id(item);
// WinData::getInstance().push_back(item, data->getRate(id, WinData::getInstance().getRate()));
// }
// // //_opComp = Orz::ComponentFactories::getInstance().create("OperatingPanel");
// }
// ~SetWinMsg(void)
// {
// }
// void init(WheelGame * game)
// {
// assert(game);
// //_communicate = game->getHardware()->queryInterface<CommunicateInterface>();
// }
// void exit(void)
// {
//
//
// }
// bool send(Orz::CommunicateInterface::PanelID id)
// {
// const WinData::Bonus & bonus = WinData::getInstance().getBonus();
// WheelEnum::Winner winner = WinData::getInstance().getWinner();
// OperatingPanelInterface * operation = //_opComp->queryInterface<OperatingPanelInterface>();
// size_t score = operation->testAnimal2Player(CommunicateInterface::PanelID(id), _prototype);
// int table = Orz::WinData::getInstance().getTable();
//
//
// score += operation->testWinner2Player(id, winner);
//
// if(bonus.has)
// {
// score += operation->getAnimalCoins(id) * bonus.profitForPerInvest;
// _communicate->setScore(id, ScoreInterface::WinPrototypePtr(), score);
// }else
// {
//
// if(_prototype->winMode == WheelEnum::NONE && table == id)
// {
// score *=2;
// }
// _communicate->setScore(id, _prototype, score);
// }
// //_allScore += score;
// return false;
// }
// bool receive(CommunicateInterface::PackagePtr package, Orz::CommunicateInterface::PanelID id)
// {
// return (package->getId() == id);
// }
//private:
// Orz::ComponentPtr //_opComp;
// //ScoreInterface::WinPrototypePtr _prototype;
// //int _allScore;
// //CommunicateInterface * _communicate;
// //LockInterface * _lock;// = _dataServer->queryInterface<LockInterface>();
// //DataServerInterface * _dataServer;
//};
}
#endif | [
"[email protected]"
] | [
[
[
1,
125
]
]
] |
995d67407f588dd6496def73e8d8e79f6ab806a1 | b505ef7eb1a6c58ebcb73267eaa1bad60efb1cb2 | /source/graphics/texture2d.h | 0dad53de1385bcf0d1a382b82e79038ca2a87a59 | [] | no_license | roxygen/maid2 | 230319e05d6d6e2f345eda4c4d9d430fae574422 | 455b6b57c4e08f3678948827d074385dbc6c3f58 | refs/heads/master | 2021-01-23T17:19:44.876818 | 2010-07-02T02:43:45 | 2010-07-02T02:43:45 | 38,671,921 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,706 | h | #ifndef maid2_graphics_texture2d_h
#define maid2_graphics_texture2d_h
/*!
@file
@brief 2Dテクスチャ
*/
#include"../config/define.h"
#include"../auxiliary/globalpointer.h"
#include"../auxiliary/jobcachetemplate.h"
#include"../auxiliary/globalkeyvaluetable.h"
#include"../auxiliary/string.h"
#include"../auxiliary/functionresult.h"
#include"texture2dbase.h"
namespace Maid
{
namespace KEEPOUT
{
class tex2dInput
: public IJobInput
{
public:
typedef std::map<String,String> CREATECONFIG;
tex2dInput(){}
tex2dInput( const CREATECONFIG& conf, GraphicsCore* c )
:Config(conf), Core(c){}
CREATECONFIG Config;
GraphicsCore* Core;
};
inline bool operator < ( const tex2dInput& lha, const tex2dInput& rha )
{
return lha.Config < rha.Config;
}
class tex2dOutput
: public IJobOutput
{
public:
tex2dOutput()
:ImageSize(0,0)
,CreateSize(0,0)
,TextureSize(0,0)
{}
std::vector<SurfaceInstance> TextureData; // 作成するテクスチャデータ
SIZE2DI ImageSize; // 元画像の大きさ
SIZE2DI CreateSize; // 実際に作った大きさ
SIZE2DI TextureSize; // テクスチャバッファの大きさ
PIXELFORMAT TextureFormat; // TextureData のピクセルフォーマット
PIXELFORMAT ImageFormat; // 画像ファイルのフォーマット
};
class tex2dFunction : public IJobFunction
{
public:
void Execute( const IJobInput& Input, IJobOutput& Output );
private:
FUNCTIONRESULT LoadImage( const tex2dInput::CREATECONFIG& Element, std::vector<SurfaceInstance>& dst );
FUNCTIONRESULT ConvertSubResource( const std::vector<SurfaceInstance>& src, std::vector<SurfaceInstance>& dst );
void GenerateSublevel( std::vector<SurfaceInstance>& target, int level );
void ReadName( const String& Tag, String& Element, String& Value );
FUNCTIONRESULT LoadImageFile( const String& filename, std::vector<SurfaceInstance>& dst );
int CalcMipLevels( const GraphicsCore& core, const tex2dInput::CREATECONFIG& setting, const SIZE2DI& size ) const;
};
}
class Texture2D
:public Texture2DBase
,private GlobalPointer<GraphicsCore>
{
public:
void LoadCommand( const String& Command );
void LoadFile( const String& FileName );
void LoadFile( const String& FileName, int MipmapLevel );
bool IsLoading()const;
void Delete();
const SIZE2DI& GetImageSize()const;
bool IsEmpty() const;
String GetLoadText() const;
bool IsSetupped() const;
private:
void SendCommand( const KEEPOUT::tex2dInput::CREATECONFIG& Command );
void ReadConvertSetting( const String& Command, KEEPOUT::tex2dInput::CREATECONFIG& out );
void ReadName( const String& Tag, String& Element, String& Value );
private:
typedef JobCacheTemplate<KEEPOUT::tex2dInput,KEEPOUT::tex2dFunction, KEEPOUT::tex2dOutput> CACHE;
CACHE m_Cache;
struct TEXTUREDATA
{
Graphics::SPTEXTURE2D pTexture;
Graphics::SPMATERIAL pMaterial;
SIZE2DI ImageSize; // 元画像の大きさ
SIZE2DI CreateSize; // 実際に作った大きさ
SIZE2DI TextureSize; // テクスチャバッファの大きさ
PIXELFORMAT ImageFormat; // 画像ファイルのフォーマット
};
typedef GlobalKeyValueTable<KEEPOUT::tex2dInput::CREATECONFIG,TEXTUREDATA> TEXTURETABLE;
TEXTURETABLE m_Table;
String m_LoadText;
};
}
#endif | [
"[email protected]",
"renji2000@471aaf9e-aa7b-11dd-9b86-41075523de00"
] | [
[
[
1,
12
],
[
14,
49
],
[
51,
53
],
[
55,
103
],
[
117,
123
]
],
[
[
13,
13
],
[
50,
50
],
[
54,
54
],
[
104,
116
]
]
] |
f0e7aea274ac021ef4cb769da68995eb0ddce6e6 | bdb8fc8eb5edc84cf92ba80b8541ba2b6c2b0918 | /TPs CPOO/Gareth & Maxime/TP1/tp1 - Codeblocks/Carte.h | 69e5959b34b22b2dbf7defada2f6633cf32664f2 | [] | no_license | Issam-Engineer/tp4infoinsa | 3538644b40d19375b6bb25f030580004ed4a056d | 1576c31862ffbc048890e72a81efa11dba16338b | refs/heads/master | 2021-01-10T17:53:31.102683 | 2011-01-27T07:46:51 | 2011-01-27T07:46:51 | 55,446,817 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,755 | h | /**
*
* \file Carte.h
* \brief Header file which describes the "Carte" class
* \author Maxime HAVEZ
* \author Gareth THIVEUX
* \date 23/09/10
*
*/
#ifndef CARTE_H
#define CARTE_H
/**
* \enum Couleur
* \brief Gives the possibilities for Card colors
*/
enum Couleur {pique,trefle,coeur,carreau};
/**
* \enum Valeur
* \brief Gives the possibilities for Card values
*/
enum Valeur {as,deux,trois,quartre,cinq,six,sept,huit,neuf,dix,valet,dame,roi};
class Carte {
private:
//Class Attributes
Couleur _couleur;
Valeur _valeur;
char _proprio;
Carte* _suc;
//Static Class Attributes which are used for the list
static Carte* teteN;
static Carte* teteS;
static Carte* queueN;
static Carte* queueS;
public:
/**
* \fn Carte(Couleur c, Valeur v, char p);
* \brief Constructor with 3 parameters
*
* \param[in] c Card color
* \param[in] v Card value
* \param[in] p Card owner, represented by a char ('N' ou 'S')
*/
Carte(Couleur c, Valeur v, char p);
/**
* \fn static Carte* getNTete();
* \brief allows an access to the top element of N-packet
*
* \return the pointer on the first card of N-packet
*/
static Carte* getNTete();
/**
* \fn static Carte* getSTete();
* \brief allows an access to the top element of S-packet
*
* \return the pointer on the first card of S-packet
*/
static Carte* getSTete();
/**
* \fn static Carte* getNQueue();
* \brief allows an access to the last element of N-packet
*
* \return the pointer on the last card of N-packet
*/
static Carte* getNQueue();
/**
* \fn static Carte* getSQueue();
* \brief allows an access to the last element of S-packet
*
* \return a pointer on the last card of S-packet
*/
static Carte* getSQueue();
/**
* \fn inline Couleur Carte::couleur() const {return _couleur;}
* \brief gives an access to the current card color
*
* \return color of the current card
*/
inline Couleur couleur() const {return _couleur;}
/**
* \fn inline Valeur Carte::valeur() const {return _valeur;}
* \brief gives an access to the current card value
*
* \return value of the current card
*/
inline Valeur valeur() const {return _valeur;}
/**
* \fn inline char Carte::proprio() const {return _proprio;}
* \brief gives an access to the current card owner
*
* \return a char which represents the current card owner
*/
inline char proprio() const {return _proprio;}
/**
* \fn inline Carte* Carte::suc() const {return _suc;}
* \brief gives an access to the current card successor
*
* \return a pointer on the successor
*/
inline Carte* suc() const {return _suc;}
/**
* \fn bool supAbs(Carte c);
* \brief return true if the current element is stronger than called element
*
* \return a boolean, true if the current element is stronger false esle
*/
bool supAbs(Carte c);
/**
* \fn bool egale(Carte c);
* \brief compares two cards together and tests their equality
*
* \return a boolean, true if the elements are equals, else false
*/
bool egale(Carte c);
//methodes d'affichages
/**
* \fn void afficher();
* \brief prints a description of the current card
*/
void afficher();
/**
* \fn void afficherN();
* \brief prints the list of cards of owner 'N'
*/
static void afficherN();
/**
* \fn void afficherN();
* \brief prints the list of cards of owner 'S'
*/
static void afficherS();
/**
* \fn void changerProp();
* \brief puts the first card of the owner at the end of the other player's packet
*/
void changerProp();
/**
* \fn void passerDerriere();
* \brief puts the card at the end of the packet
*/
void passerDerriere();
};
#endif | [
"garethiveux@9f3b02c3-fd90-5378-97a3-836ae78947c6"
] | [
[
[
1,
169
]
]
] |
79f54472f90e2e780e22cb79c8cb1b99eabca8a7 | b5e490bbfe04b051c5d7cdc40a5d866119d619b8 | /Kompex-SQLite-Wrapper/src/KompexSQLiteDatabase.cpp | 35746005bc953a7f798a215919dd15eb99e1fc33 | [] | no_license | pandabear41/animetracker | 07a10acbeba40d02d28958f8c560938bd5275e61 | 7591bc021d73c1b66d7e2c15cbbfdba275faf1e8 | refs/heads/master | 2021-01-15T12:16:09.430378 | 2011-01-13T22:46:02 | 2011-01-13T22:46:02 | 1,247,216 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,416 | cpp | /*
This file is part of Kompex SQLite Wrapper.
Copyright (c) 2008-2010 Sven Broeske
Kompex SQLite Wrapper is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Kompex SQLite Wrapper is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with Kompex SQLite Wrapper. If not, see <http://www.gnu.org/licenses/>.
*/
#include <fstream>
#include <iostream>
#include <exception>
#include "KompexSQLiteDatabase.h"
#include "KompexSQLiteException.h"
namespace Kompex
{
SQLiteDatabase::SQLiteDatabase():
mDatabaseHandle(0),
mIsMemoryDatabaseActive(false)
{
}
SQLiteDatabase::SQLiteDatabase(const char *filename, int flags, const char *zVfs):
mDatabaseHandle(0),
mIsMemoryDatabaseActive(false)
{
Open(filename, flags, zVfs);
}
SQLiteDatabase::SQLiteDatabase(const wchar_t *filename):
mDatabaseHandle(0),
mIsMemoryDatabaseActive(false)
{
Open(filename);
}
SQLiteDatabase::SQLiteDatabase(const std::string &filename, int flags, const char *zVfs):
mDatabaseHandle(0),
mIsMemoryDatabaseActive(false)
{
Open(filename, flags, zVfs);
}
SQLiteDatabase::~SQLiteDatabase()
{
Close();
}
void SQLiteDatabase::Open(const char *filename, int flags, const char *zVfs)
{
// close old db, if one exist
if(mDatabaseHandle)
Close();
if(sqlite3_open_v2(filename, &mDatabaseHandle, flags, zVfs) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(mDatabaseHandle));
mDatabaseFilename = std::string(filename);
}
void SQLiteDatabase::Open(const std::string &filename, int flags, const char *zVfs)
{
// close old db, if one exist
if(mDatabaseHandle)
Close();
if(sqlite3_open_v2(filename.c_str(), &mDatabaseHandle, flags, zVfs) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(mDatabaseHandle));
mDatabaseFilename = std::string(filename);
}
void SQLiteDatabase::Open(const wchar_t *filename)
{
// close old db, if one exist
if(mDatabaseHandle)
Close();
if(sqlite3_open16(filename, &mDatabaseHandle) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(mDatabaseHandle));
}
void SQLiteDatabase::Close()
{
// detach database if the database was moved into memory
if(mIsMemoryDatabaseActive)
{
if(sqlite3_exec(mDatabaseHandle, "DETACH DATABASE origin", 0, 0, 0) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(mDatabaseHandle));
}
if(mDatabaseHandle && sqlite3_close(mDatabaseHandle) != SQLITE_OK)
{
KOMPEX_EXCEPT(sqlite3_errmsg(mDatabaseHandle));
}
else
{
mDatabaseHandle = 0;
mDatabaseFilename = "";
mIsMemoryDatabaseActive = false;
}
}
void SQLiteDatabase::TraceOutput(void *ptr, const char *sql)
{
std::cout << "trace: " << sql << std::endl;
}
void SQLiteDatabase::ProfileOutput(void* ptr, const char* sql, sqlite3_uint64 time)
{
std::cout << "profile: " << sql << std::endl;
std::cout << "profile time: " << time << std::endl;
}
void SQLiteDatabase::MoveDatabaseToMemory()
{
if(!mIsMemoryDatabaseActive)
{
if(mDatabaseFilename == "")
{
KOMPEX_EXCEPT("Can't move a database with a UTF16 filename to memory!");
return;
}
sqlite3 *memoryDatabase;
sqlite3_open(":memory:", &memoryDatabase);
// create the in-memory schema from the origin database
sqlite3_exec(mDatabaseHandle, "BEGIN", 0, 0, 0);
sqlite3_exec(mDatabaseHandle, "SELECT sql FROM sqlite_master WHERE sql NOT NULL", &Kompex::SQLiteDatabase::ProcessDDLRow, memoryDatabase, 0);
sqlite3_exec(mDatabaseHandle, "COMMIT", 0, 0, 0);
sqlite3_close(mDatabaseHandle);
// attach the origin databse to the in-memory
std::string sql = "ATTACH DATABASE '" + mDatabaseFilename + "' as origin";
if(sqlite3_exec(memoryDatabase, sql.c_str(), 0, 0, 0) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(memoryDatabase));
// copy the data from the origin databse to the in-memory
sqlite3_exec(memoryDatabase, "BEGIN", 0, 0, 0);
sqlite3_exec(memoryDatabase, "SELECT name FROM origin.sqlite_master WHERE type='table'", &Kompex::SQLiteDatabase::ProcessDMLRow, memoryDatabase, 0);
sqlite3_exec(memoryDatabase, "COMMIT", 0, 0, 0);
mDatabaseHandle = memoryDatabase;
mIsMemoryDatabaseActive = true;
}
}
int SQLiteDatabase::ProcessDDLRow(void *db, int columnsCount, char **values, char **columns)
{
if(columnsCount != 1)
{
KOMPEX_EXCEPT("error occured during DDL: columnsCount != 1");
return -1;
}
// execute a sql statement in values[0] in the database db.
if(sqlite3_exec(static_cast<sqlite3*>(db), values[0], 0, 0, 0) != SQLITE_OK)
KOMPEX_EXCEPT("error occured during DDL: sqlite3_exec");
return 0;
}
int SQLiteDatabase::ProcessDMLRow(void *db, int columnsCount, char **values, char **columns)
{
if(columnsCount != 1)
{
KOMPEX_EXCEPT("error occured during DML: columnsCount != 1");
return -1;
}
char *stmt = sqlite3_mprintf("INSERT INTO main.%q SELECT * FROM origin.%q", values[0], values[0]);
if(sqlite3_exec(static_cast<sqlite3*>(db), stmt, 0, 0, 0) != SQLITE_OK)
KOMPEX_EXCEPT("error occured during DML: sqlite3_exec");
sqlite3_free(stmt);
return 0;
}
void SQLiteDatabase::SaveDatabaseFromMemoryToFile(const std::string &filename)
{
if(mIsMemoryDatabaseActive)
{
std::string file = filename;
if(file == "")
file = mDatabaseFilename;
sqlite3 *fileDatabase;
if(sqlite3_open_v2(file.c_str(), &fileDatabase, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(fileDatabase));
sqlite3_backup *backup;
backup = sqlite3_backup_init(fileDatabase, "main", mDatabaseHandle, "main");
if(backup)
{
if(sqlite3_backup_step(backup, -1) != SQLITE_DONE)
KOMPEX_EXCEPT(sqlite3_errmsg(fileDatabase));
if(sqlite3_backup_finish(backup) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(fileDatabase));
}
if(sqlite3_close(fileDatabase) != SQLITE_OK)
KOMPEX_EXCEPT(sqlite3_errmsg(fileDatabase));
}
}
} // namespace Kompex
| [
"[email protected]"
] | [
[
[
1,
219
]
]
] |
535650287754b46b2d6dad04ac2b47bd76edf744 | 3e69b159d352a57a48bc483cb8ca802b49679d65 | /tags/release-2006-01-06/pcbnew/move_copy_track.cpp | da8ca930310a0b985dbba459ed94f05a406f4338 | [] | no_license | BackupTheBerlios/kicad-svn | 4b79bc0af39d6e5cb0f07556eb781a83e8a464b9 | 4c97bbde4b1b12ec5616a57c17298c77a9790398 | refs/heads/master | 2021-01-01T19:38:40.000652 | 2006-06-19T20:01:24 | 2006-06-19T20:01:24 | 40,799,911 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,101 | cpp | /****************************************************/
/* Edition des pistes */
/* Routines de duplication et deplacement de pistes */
/****************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"
#include "autorout.h"
#include "drag.h"
#include "protos.h"
/* Routines externes */
static void Show_MoveTrack(WinEDA_DrawPanel * panel, wxDC * DC, bool erase);
static void Exit_MoveTrack(WinEDA_DrawFrame * frame, wxDC *DC);
#if 0
/* Routines Locales */
static void Duplic_Track(COMMAND * Cmd);
static void Place_Dupl_Route(COMMAND * Cmd);
#endif
/* variables locales */
static wxPoint PosInit, LastPos;
static TRACK * NewTrack; /* Nouvelle piste creee ou piste deplacee */
static int NbPtNewTrack;
static int Old_HightLigth_NetCode;
static bool Old_HightLigt_Status;
/**************************************************************/
static void Exit_MoveTrack(WinEDA_DrawFrame * frame, wxDC *DC)
/***************************************************************/
/* routine d'annulation de la commande drag, copy ou move track si une piste est en cours
de tracage, ou de sortie de l'application EDITRACK.
Appel par la touche ESC
*/
{
TRACK * NextS;
int ii;
/* Effacement du trace en cours */
wxPoint oldpos = frame->GetScreen()->m_Curseur;
frame->GetScreen()->m_Curseur = PosInit;
frame->GetScreen()->ManageCurseur(frame->DrawPanel, DC, TRUE);
frame->GetScreen()->m_Curseur = oldpos;
g_HightLigt_Status = FALSE;
( (WinEDA_PcbFrame *)frame)->DrawHightLight( DC, g_HightLigth_NetCode) ;
if( NewTrack )
{
if (NewTrack->m_Flags & IS_NEW )
{
for( ii = 0; ii < NbPtNewTrack; ii++, NewTrack = NextS)
{
if(NewTrack == NULL) break;
NextS = (TRACK*) NewTrack->Pnext;
delete NewTrack;
}
}
else /* Move : remise en ancienne position */
{
TRACK * Track = NewTrack;
int dx = LastPos.x - PosInit.x;
int dy = LastPos.y - PosInit.y;
for( ii = 0; ii < NbPtNewTrack; ii++, Track = (TRACK*) Track->Pnext)
{
if( Track == NULL ) break;
Track->m_Start.x -= dx;
Track->m_Start.y -= dy;
Track->m_End.x -= dx;
Track->m_End.y -= dy;
Track->m_Flags = 0;
}
Trace_Une_Piste(frame->DrawPanel, DC, NewTrack,NbPtNewTrack,GR_OR);
}
NewTrack = NULL;
}
frame->GetScreen()->ManageCurseur = NULL;
frame->GetScreen()->ForceCloseManageCurseur = NULL;
frame->GetScreen()->m_CurrentItem = NULL;
frame->EraseMsgBox();
/* Annulation deplacement et Redessin des segments dragges */
DRAG_SEGM * pt_drag = g_DragSegmentList;
for( ; pt_drag != NULL; pt_drag = pt_drag->Pnext)
{
TRACK * Track = pt_drag->m_Segm;
pt_drag->SetInitialValues();
Track->SetState(EDIT,OFF);
Track->m_Flags = 0;
Track->Draw(frame->DrawPanel, DC, GR_OR);
}
g_HightLigth_NetCode = Old_HightLigth_NetCode;
g_HightLigt_Status = Old_HightLigt_Status;
if(g_HightLigt_Status)
( (WinEDA_PcbFrame *)frame)->DrawHightLight( DC, g_HightLigth_NetCode) ;
EraseDragListe();
}
/*************************************************************************/
static void Show_MoveTrack(WinEDA_DrawPanel * panel, wxDC * DC, bool erase)
/*************************************************************************/
/* redessin du contour de la piste lors des deplacements de la souris */
{
int ii, dx, dy;
TRACK * Track;
BASE_SCREEN * screen = panel->GetScreen();
int track_fill_copy = DisplayOpt.DisplayPcbTrackFill;
DisplayOpt.DisplayPcbTrackFill = SKETCH ;
erase = TRUE;
/* efface ancienne position si elle a ete deja dessinee */
if( erase )
{
if ( NewTrack ) Trace_Une_Piste(panel, DC, NewTrack,NbPtNewTrack,GR_XOR) ;
}
/* mise a jour des coordonnees des segments de la piste */
wxPoint Pos = screen->m_Curseur;
dx = Pos.x - LastPos.x;
dy = Pos.y - LastPos.y;
LastPos = Pos;
ii = NbPtNewTrack, Track = NewTrack;
for( ; ii > 0; ii--, Track = Track->Next() )
{
if( Track->m_Flags & STARTPOINT)
{
Track->m_Start.x += dx; Track->m_Start.y += dy;
}
if( Track->m_Flags & ENDPOINT)
{
Track->m_End.x += dx; Track->m_End.y += dy;
}
}
/* dessin de la nouvelle piste */
Trace_Une_Piste(panel, DC, NewTrack,NbPtNewTrack,GR_XOR) ;
/* Tracage des segments dragges */
DRAG_SEGM * pt_drag = g_DragSegmentList;
for( ; pt_drag != NULL; pt_drag = pt_drag->Pnext)
{
Track = pt_drag->m_Segm;
if ( erase ) Track->Draw(panel, DC, GR_XOR);
if( Track->m_Flags & STARTPOINT)
{
Track->m_Start.x += dx; Track->m_Start.y += dy;
}
if( Track->m_Flags & ENDPOINT)
{
Track->m_End.x += dx; Track->m_End.y += dy;
}
Track->Draw(panel, DC, GR_XOR);
}
DisplayOpt.DisplayPcbTrackFill = track_fill_copy ;
}
/***********************************************************************************/
void WinEDA_PcbFrame::Start_MoveOneTrackSegment(TRACK * track, wxDC * DC, bool Drag)
/***********************************************************************************/
{
/* Change hight light net: the new one will be hightlighted */
Old_HightLigt_Status = g_HightLigt_Status;
Old_HightLigth_NetCode = g_HightLigth_NetCode;
if(g_HightLigt_Status) Hight_Light(DC);
if ( Drag && track->m_StructType == TYPEVIA)
{
track->m_Flags = IS_DRAGGED|STARTPOINT|ENDPOINT;
Collect_TrackSegmentsToDrag(DrawPanel, DC, track->m_Start,
track->ReturnMaskLayer(), track->m_NetCode);
NewTrack = track;
NbPtNewTrack = 1;
PosInit = track->m_Start;
}
else
{
int diag = track->IsPointOnEnds(GetScreen()->m_Curseur, -1);
wxPoint pos = (diag & STARTPOINT) ? track->m_Start : track->m_End;
Collect_TrackSegmentsToDrag(DrawPanel, DC, pos,
track->ReturnMaskLayer(), track->m_NetCode);
track->m_Flags |= IS_DRAGGED;
NewTrack = NULL;
NbPtNewTrack = 0;
PosInit = pos;
}
LastPos = PosInit;
GetScreen()->ManageCurseur = Show_MoveTrack;
GetScreen()->ForceCloseManageCurseur = Exit_MoveTrack;
g_HightLigth_NetCode = track->m_NetCode;
g_HightLigt_Status = TRUE;
DrawHightLight( DC, g_HightLigth_NetCode) ;
GetScreen()->ManageCurseur(DrawPanel, DC, TRUE);
}
/**********************************************************************/
bool WinEDA_PcbFrame::PlaceDraggedTrackSegment(TRACK * Track, wxDC * DC)
/**********************************************************************/
/* Place a dragged track segment or via */
{
int errdrc;
DRAG_SEGM * pt_drag;
if(Track == NULL ) return FALSE;
// DRC control:
if(Drc_On)
{
errdrc = Drc(this, DC, Track, m_Pcb->m_Track,1);
if(errdrc == BAD_DRC) return FALSE;
/* Tracage des segments dragges */
pt_drag = g_DragSegmentList;
for( ; pt_drag; pt_drag = pt_drag->Pnext)
{
errdrc = Drc(this, DC, pt_drag->m_Segm, m_Pcb->m_Track,1);
if(errdrc == BAD_DRC) return FALSE;
}
}
// DRC Ok: place track segments
Track->m_Flags = 0;
Track->Draw(DrawPanel, DC, GR_OR);
/* Tracage des segments dragges */
pt_drag = g_DragSegmentList;
for( ; pt_drag; pt_drag = pt_drag->Pnext)
{
Track = pt_drag->m_Segm;
Track->SetState(EDIT,OFF);
Track->m_Flags = 0;
Track->Draw(DrawPanel, DC, GR_OR);
}
EraseDragListe();
GetScreen()->SetModify();
GetScreen()->ManageCurseur = NULL;
GetScreen()->ForceCloseManageCurseur = NULL;
return TRUE;
}
#if 0
/***********************************************/
void WinEDA_PcbFrame::Place_Dupl_Route(Track * Track, wxDC * DC)
/******************************************/
/*
Routine de placement d'une piste (succession de segments)
*/
{
D_PAD * pt_pad;
TRACK * pt_track, *Track, * pt_classe, *NextS;
int masquelayer;
EDA_BaseStruct * LockPoint;
int ii, old_net_code, new_net_code, DRC_error = 0;
wxDC * DC = Cmd->DC;
ActiveScreen->ManageCurseur = NULL;
if( NewTrack == NULL ) return ;
old_net_code = NewTrack->net_code;
/* Placement du flag BUSY de la piste originelle, qui ne doit
pas etre vue dans les recherches de raccordement suivantes */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->SetState(BUSY, ON);
}
/* Detection du nouveau net_code */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->net_code = 0;
}
new_net_code = 0;
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack ; ii++, pt_track = (TRACK*)pt_track->Pnext)
{
/* Localisation de la pastille ou segment en debut de segment: */
masquelayer = tab_layer[pt_track->Layer];
LockPoint = LocateLockPoint(pt_track->m_Start.x,pt_track->m_Start.y,masquelayer);
if( LockPoint )
{
if ( LockPoint->m_StructType == TYPEPAD )
{
pt_pad = (D_PAD*) LockPoint;
new_net_code = pt_pad->net_code;
if ( new_net_code > 0 ) break;
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
new_net_code = Track->net_code;
if ( new_net_code > 0 ) break;
}
}
LockPoint = LocateLockPoint(pt_track->m_End.x,pt_track->m_End.y,masquelayer);
if( LockPoint )
{
if ( LockPoint->m_StructType == TYPEPAD )
{
pt_pad = (D_PAD*) LockPoint;
new_net_code = pt_pad->net_code;
if ( new_net_code > 0 ) break;
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
new_net_code = Track->net_code;
if ( new_net_code > 0 ) break;
}
}
}
/* Mise a jour du nouveau net code de la piste */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = (TRACK*)pt_track->Pnext)
{
pt_track->net_code = new_net_code;
}
/* Controle DRC de la nouvelle piste */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = pt_track->Next() )
{
if( Drc_On == RUN )
if( drc(DC, pt_track, pt_pcb->Track, 1) == BAD_DRC )
{
if( confirmation(" Erreur DRC, Place piste:") == YES ) continue;
else { DRC_error = 1; break; }
}
}
if( DRC_error == 0)
{
if(FlagState == MOVE_ROUTE)
{
/* copie nouvelle piste */
pt_track = NewTrack;
NewTrack = pt_track->Copy(NbPtNewTrack);
/* effacement ancienne ( chainage et liens mauvais */
ii = NbPtNewTrack;
for ( ; ii > 0; ii --, pt_track = NextS)
{
NextS = (TRACK*) pt_track->Pnext;
DeleteStructure(pt_track);
}
test_1_net_connexion(DC, old_net_code );
}
pt_classe = NewTrack->GetBestInsertPoint();
NewTrack->Insert(pt_classe);
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_OR) ;
/* Mise a jour des connexions sur pads et sur pistes */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = NextS)
{
NextS = (TRACK*)pt_track->Pnext;
pt_track->SetState(BEGIN_ONPAD|END_ONPAD, OFF);
masquelayer = tab_layer[pt_track->Layer];
/* Localisation de la pastille ou segment sur debut segment: */
LockPoint = LocateLockPoint(pt_track->m_Start.x,pt_track->m_Start.y,masquelayer);
if( LockPoint )
{
pt_track->start = LockPoint;
if ( LockPoint->m_StructType == TYPEPAD )
{ /* fin de piste sur un pad */
pt_pad = (D_PAD*) LockPoint;
pt_track->SetState(BEGIN_ONPAD, ON);
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
CreateLockPoint(&pt_track->m_Start.x,&pt_track->m_Start.y,Track,pt_track);
}
}
/* Localisation de la pastille ou segment sur fin de segment: */
LockPoint = LocateLockPoint(pt_track->m_End.x,pt_track->m_End.y,masquelayer);
if( LockPoint )
{
pt_track->end = LockPoint;
if ( LockPoint->m_StructType == TYPEPAD )
{ /* fin de piste sur un pad */
pt_pad = (D_PAD*) LockPoint;
pt_track->SetState(END_ONPAD, ON);
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
CreateLockPoint(&pt_track->m_Start.x,&pt_track->m_Start.y,Track,pt_track);
}
}
}
/* Suppression du flag BUSY */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->SetState(BUSY, OFF);
}
test_1_net_connexion(DC, new_net_code );
ActiveScreen->SetModify();
}
else /* Erreur DRC: Annulation commande */
{
DisplayOpt.DisplayPcbTrackFill = SKETCH ;
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_XOR);
DisplayOpt.DisplayPcbTrackFill = Track_fill_copy ;
if(FlagState == MOVE_ROUTE)
{ /* Remise en position de la piste deplacee */
Track = NewTrack;
PosInitX -= Track->m_Start.x; PosInitY -= Track->m_Start.y;
for( ii = 0; ii < NbPtNewTrack; ii++, Track = (TRACK*) Track->Pnext)
{
if( Track == NULL ) break;
Track->m_Start.x += PosInitX; Track->m_Start.y += PosInitY;
Track->m_End.x += PosInitX; Track->m_End.y += PosInitY;
Track->SetState(BUSY,OFF);
}
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_OR);
}
if (FlagState == COPY_ROUTE )
{ /* Suppression copie */
for( ii = 0; ii < NbPtNewTrack; NewTrack = NextS)
{
if(NewTrack == NULL) break;
NextS = (TRACK*) NewTrack->Pnext;
delete NewTrack;
}
}
}
NewTrack = NULL;
Affiche_Infos_Status_Pcb(Cmd);
if(Etat_Surbrillance) Hight_Light(DC);
}
/************************************************/
void WinEDA_PcbFrame::Start_CopieMove_Route(TRACK * track, wxDC * DC, bool Drag)
/************************************************/
/* Routine permettant la recopie d'une piste (suite de segments) deja tracee
*/
{
int ii;
TRACK *pt_segm, *pt_track;
int masquelayer = tab_layer[ActiveScreen->Active_Layer];
wxDC * DC = Cmd->DC;
if( NewTrack ) return;
FlagState = (int)Cmd->Menu->param_inf;
/* Recherche de la piste sur la couche active (non zone) */
for(pt_segm = pt_pcb->Track; pt_segm != NULL; pt_segm = (TRACK*)pt_segm->Pnext)
{
pt_segm = Locate_Pistes(pt_segm,masquelayer, CURSEUR_OFF_GRILLE);
if( pt_segm == NULL ) break ;
break ;
}
if( pt_segm != NULL )
{
if (FlagState == COPY_ROUTE )
pt_track = Marque_Une_Piste(DC, pt_segm, &NbPtNewTrack, 0);
else pt_track = Marque_Une_Piste(DC, pt_segm, &NbPtNewTrack, GR_XOR);
if(NbPtNewTrack) /* Il y a NbPtNewTrack segments de piste a traiter */
{
/* effacement du flag BUSY de la piste originelle */
ii = NbPtNewTrack; pt_segm = pt_track;
for ( ; ii > 0; ii --, pt_segm = (TRACK*) pt_segm->Pnext)
{
pt_segm->SetState(BUSY, OFF);
}
if (FlagState == COPY_ROUTE )
NewTrack = pt_track->Copy(NbPtNewTrack);
else NewTrack = pt_track;
Affiche_Infos_Piste(Cmd, pt_track) ;
startX = ActiveScreen->Curseur_X;
startY = ActiveScreen->Curseur_Y;
Place_Dupl_Route_Item.State = WAIT;
ActiveScreen->ManageCurseur = Show_Move_Piste;
DisplayOpt.DisplayPcbTrackFill = SKETCH ;
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_XOR) ;
DisplayOpt.DisplayPcbTrackFill = Track_fill_copy ;
PosInitX = NewTrack->m_Start.x; PosInitY = NewTrack->m_Start.y;
}
}
}
#endif
/************************************************************************/
EDA_BaseStruct * LocateLockPoint(BOARD * Pcb, wxPoint pos, int LayerMask)
/************************************************************************/
/* Routine trouvant le point " d'accrochage " d'une extremite de piste.
Ce point peut etre un PAD ou un autre segment de piste
Retourne:
- pointeur sur ce PAD ou:
- pointeur sur le segment ou:
- NULL
Parametres d'appel:
coord pX, pY du point tst
masque des couches a tester
*/
{
D_PAD * pt_pad;
TRACK * ptsegm;
MODULE * Module;
/* detection du point type PAD */
pt_pad = NULL;
Module = Pcb->m_Modules;
for( ; Module != NULL; Module = (MODULE*)Module->Pnext )
{
pt_pad = Locate_Pads(Module,pos.x, pos.y, LayerMask);
if (pt_pad) return(pt_pad);
}
/* ici aucun pad n'a ete localise: detection d'un segment de piste */
ptsegm = Fast_Locate_Piste( Pcb->m_Track, NULL, pos.x, pos.y, LayerMask);
if( ptsegm == NULL )
ptsegm = Locate_Pistes( Pcb->m_Track, pos.x, pos.y, LayerMask);
return(ptsegm);
}
/******************************************************************************/
TRACK * CreateLockPoint(int *pX, int *pY, TRACK * ptsegm, TRACK * refsegm)
/******************************************************************************/
/* Routine de creation d'un point intermediaire sur un segment
le segment ptsegm est casse en 2 segments se raccordant au point pX, pY
retourne:
NULL si pas de nouveau point ( c.a.d si pX, pY correspondait deja
a une extremite ou:
pointeur sur le segment cree
si refsegm != NULL refsegm est pointeur sur le segment incident,
et le point cree est l'intersection des 2 axes des segments ptsegm et
refsegm
retourne la valeur exacte de pX et pY
Si ptsegm pointe sur une via:
retourne la valeur exacte de pX et pY et ptsegm,
mais ne cree pas de point supplementaire
*/
{
int cX, cY;
int dx, dy; /* Coord de l'extremite du segm ptsegm / origine */
int ox, oy, fx , fy; /* coord de refsegm / origine de prsegm */
TRACK * NewTrack;
if( (ptsegm->m_Start.x == *pX) && (ptsegm->m_Start.y == *pY) ) return(NULL);
if( (ptsegm->m_End.x == *pX) && (ptsegm->m_End.y == *pY) ) return(NULL);
/* le point n'est pas sur une extremite de piste */
if(ptsegm->m_StructType == TYPEVIA )
{
*pX = ptsegm->m_Start.x; *pY = ptsegm->m_Start.y;
return(ptsegm);
}
/* calcul des coord vraies du point intermediaire dans le repere d'origine
= origine de ptsegm */
cX = *pX - ptsegm->m_Start.x;
cY = *pY - ptsegm->m_Start.y;
dx = ptsegm->m_End.x - ptsegm->m_Start.x;
dy = ptsegm->m_End.y - ptsegm->m_Start.y;
// ***** A COMPLETER : non utilise
if ( refsegm )
{
ox = refsegm->m_Start.x - ptsegm->m_Start.x;
oy = refsegm->m_Start.y - ptsegm->m_Start.y;
fx = refsegm->m_End.x - ptsegm->m_Start.x;
fy = refsegm->m_End.y - ptsegm->m_Start.y;
}
/* pour que le point soit sur le segment ptsegm: cY/cX = dy/dx */
if ( dx == 0 ) cX = 0; /* segm horizontal */
else cY = (cX * dy) / dx;
/* creation du point intermediaire ( c'est a dire creation d'un nouveau
segment, debutant au point intermediaire */
cX += ptsegm->m_Start.x; cY += ptsegm->m_Start.y;
NewTrack = ptsegm->Copy();
NewTrack->Insert(NULL, ptsegm);
/* correction du pointeur de fin du nouveau segment */
NewTrack->end = ptsegm->end;
/* le segment primitif finit au nouveau point : */
ptsegm->m_End.x = cX; ptsegm->m_End.y = cY;
ptsegm->SetState(END_ONPAD, OFF);
/* le nouveau segment debute au nouveau point : */
ptsegm = NewTrack;;
ptsegm->m_Start.x = cX; ptsegm->m_Start.y = cY;
ptsegm->SetState(BEGIN_ONPAD, OFF);
*pX = cX; *pY = cY;
return(ptsegm);
}
| [
"bokeoa@244deca0-f506-0410-ab94-f4f3571dea26"
] | [
[
[
1,
645
]
]
] |
f48e92e0b706bbc9b3a15ccb311688d72cfcfb98 | b957e10ed5376dbe85c07bdef1f510f641984a1a | /Entity.cpp | 8ca5cadfc1d3103efe7a8228e5de1fe7187cea12 | [] | no_license | alexjshank/motors | 063245c206df936a886f72a22f0f15c78e1129cb | 7193b729466d8caece267f0b8ddbf16d99c13f8a | refs/heads/master | 2016-09-10T15:47:20.906269 | 2009-11-04T18:41:21 | 2009-11-04T18:41:21 | 33,394,870 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,242 | cpp |
#include "Task.h"
#include "Quadtree.h"
#include "Timer.h"
#include "graphics.h"
#include ".\entity.h"
#include "terrain.h"
#include "EnvironmentObject.h"
#include "lassoselector.h"
#include "trigger.h"
#include "waypoint.h"
//#include "storm.h"
extern Graphics *renderer;
extern LassoSelector *selector;
extern EntityContainer *ents;
extern Timer *timer;
extern Terrain *terrain;
ENT_TASK *ENT_TASK::CreateScriptedTask(std::string action) {
scriptedAction = action;
type = SCRIPTEDACTION;
return this;
}
ENT_TASK *ENT_TASK::CreateFollow(Entity *entityToFollow) {
target = entityToFollow;
type = FOLLOW;
return this;
}
ENT_TASK *ENT_TASK::CreateMove(Vector moveto) {
position = moveto;
type = MOVE;
return this;
}
ENT_TASK *ENT_TASK::CreateAttack(Entity *t) {
target = t;
type = ATTACK;
return this;
}
ENT_TASK *ENT_TASK::CreateRepair(Entity *t) {
target = t;
type = REPAIR;
return this;
}
// t is the building that has already been created & placed but has a health of 0
ENT_TASK *ENT_TASK::CreateBuild(Entity *t) {
target = t;
type = BUILD;
return this;
}
Entity::Entity(void) {
size = Vector(0,0,0);
leaf = NULL;
health = 0;
maxhealth = 0;
completed = 0;
tooltip.enabled = false;
tooltip.tooltip = "";
tooltip.subtitle = "";
lastPathTime = 0;
Attached = false;
}
Entity::~Entity(void)
{
}
void Entity::Attach(Entity *attach_to) {
Attached = true;
AttachedTo = attach_to;
}
void Entity::process() {
position += velocity * timer->frameScalar;
}
void Entity::render() {
renderToolTip();
}
void Entity::renderToolTip() {
if (tooltip.enabled && dist2(position,selector->LassoPosition) < 4) {
renderer->text.printpositional(position + Vector(0,size.y+1,0),"%s %s",tooltip.tooltip.c_str(), tooltip.subtitle.c_str());
}
}
void Entity::interact(Entity *source, int type) {
switch (type) {
case EI_ATTACK:
health -= source->damage;
if (health <= 0)
Kill();
break;
}
}
Entity * Entity::PathToNearest(unsigned int requiredType, unsigned int requiredFamily, bool requireAlive, unsigned int requiredTeam) {
Entity *ent = ents->qtree.tree->getClosestEntity(position,requiredType,requiredFamily,requireAlive,requiredTeam);
if (!PathTo(ent))
return 0;
return ent;
}
bool Entity::PathTo(Entity *target) {
if (target) {
return PathTo(target->position);
}
return false;
}
bool Entity::PathTo(Vector p) {
if (p.x < 0 || p.z < 0) return false; // blah! deese'ere varmants shoube toss overboar'!
bool pathed = false;
int tries = 1;
AS_Node *end;
do {
end = terrain->AStarSearch(position,p + (Normalize(position - p) * (float)tries));
} while (!end && tries++ < 6);
if (!end) return false;
Vector startp = position;
startp.y = 0;
int pathlength = 0;
int maxPathLength = 30;
while (end && (end->position-startp).len2() > 1) {
ENT_TASK *newtask = new ENT_TASK;
QueueTask(newtask->CreateMove(end->position),true);
if (end == end->parent) break;
if (pathlength++ > maxPathLength) break;
end = end->parent;
}
return true;
}
bool Entity::QueueTask(ENT_TASK *newTask,bool front) {
if (newTask) {
if (front)
taskQueue.push_front(newTask);
else
taskQueue.push_back(newTask);
return true;
}
return false;
}
ENT_TASK *Entity::GetTask() {
if (taskQueue.size() > 0) {
ENT_TASK *task = taskQueue.front();
taskQueue.pop_front();
return task;
}
return 0;
}
void Entity::ClearTasks() {
taskQueue.clear();
state = Stopped; // we aren't doing anything so set us to stopped
}
void Entity::Remove() {
selector->Unselect(this);
int s = (int)ents->entities.size();
if (leaf) leaf->RemoveEntity(this);
leaf = 0;
for (int i=0;i<s;i++) {
if (ents->entities[i] == this) {
ents->entities[i] = 0;
break;
}
}
delete this;
}
void Entity::Kill() {
alive = false;
deathTime = timer->time;
}
int Entity::Serialize(unsigned char *byteData, int maxSize) { // returns number of bytes written to byteData
struct flattened {
float x,y;
} flat;
flat.x = this->position.x;
flat.y = this->position.z;
return 0;
}
int Entity::Deserialize(const unsigned char *data) {
return 0;
}
EntityContainer::EntityContainer() {
entities.clear();
priority = TP_GAME;
last_id = 0;
qtree.createTree(Vector(128,0,128),128,5);
}
void EntityContainer::AddEntity(Entity *ent) {
if (!ent) return;
ent->id = last_id++;
entities.push_back(ent);
if (ent->size.len2() > 0) {
qtree.AddEntity(ent);
}
ent->init();
}
void EntityContainer::run() {
float a,size;
int s = (int)entities.size();
for (int i=0;i<s;i++) {
Entity *e = entities[i];
if (e) {
if (e->leaf) {
size=e->leaf->getSize();
a = (float)(e->leaf->getPosition() - e->position).len();
if (a > size && e->leaf->getParent()) {
// and we're out of range of that leaf,
e->leaf->RemoveEntity(e);
qtree.AddEntity(e);
}
} else {
qtree.AddEntity(e);
}
e->process();
}
}
for (int i=0;i<s;i++) {
Entity *e = entities[i];
if (e) {
e->render();
}
}
}
| [
"alexjshank@0c9e2a0d-1447-0410-93de-f5a27bb8667b",
"[email protected]@0c9e2a0d-1447-0410-93de-f5a27bb8667b"
] | [
[
[
1,
6
],
[
8,
10
],
[
12,
20
],
[
26,
66
],
[
68,
194
],
[
201,
236
],
[
238,
257
]
],
[
[
7,
7
],
[
11,
11
],
[
21,
25
],
[
67,
67
],
[
195,
200
],
[
237,
237
]
]
] |
18de412308cb559ceaa7ce9dc1085264ffa99be8 | 27d5670a7739a866c3ad97a71c0fc9334f6875f2 | /CPP/Targets/WayFinder/symbian-r6/WavPlayer.cpp | dbb6a53f6e606d231c1780c3990a84b83d16be76 | [
"BSD-3-Clause"
] | permissive | ravustaja/Wayfinder-S60-Navigator | ef506c418b8c2e6498ece6dcae67e583fb8a4a95 | 14d1b729b2cea52f726874687e78f17492949585 | refs/heads/master | 2021-01-16T20:53:37.630909 | 2010-06-28T09:51:10 | 2010-06-28T09:51:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,624 | cpp | /*
Copyright (c) 1999 - 2010, Vodafone Group Services Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the Vodafone Group Services Ltd nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// INCLUDE FILES
#include "WavPlayer.h"
// ---------------------------------------------------------
// CWavPlayer::ConstructL(const TRect& aRect)
// EPOC two phased constructor
// ---------------------------------------------------------
//
CWavPlayer::CWavPlayer()
{
}
// Destructor
CWavPlayer::~CWavPlayer()
{
}
void CWavPlayer::Play()
{
}
void CWavPlayer::SetVolume( TInt aVolume )
{
if( aVolume < KMaxVolume )
iVolume = aVolume;
else
iVolume = KMaxVolume;
}
void CWavPlayer::SetRepeats( TInt aRepeatNumberOfTimes,
const TTimeIntervalMicroSeconds& aTrailingSilence )
{
iRepeatNumberOfTimes = aRepeatNumberOfTimes;
iTrailingSilence = aTrailingSilence;
}
void CWavPlayer::SetVolumeRamp( const TTimeIntervalMicroSeconds& aRampDuration )
{
iRampDuration = aRampDuration;
}
void CWavPlayer::Stop()
{
}
const TTimeIntervalMicroSeconds& CWavPlayer::Duration()
{
return iDuration;
}
TInt CWavPlayer::MaxVolume()
{
return KMaxVolume;
}
// End of File
| [
"[email protected]"
] | [
[
[
1,
70
]
]
] |
5ce4fd94de35e5e6c15cd983d9b5f90034c2d9d0 | 222bc22cb0330b694d2c3b0f4b866d726fd29c72 | /src/brookbox/wm2/WmlDlodNode.h | cd9154cb9f60b371958c398dd563f8db9645916e | [
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | darwin/inferno | 02acd3d05ca4c092aa4006b028a843ac04b551b1 | e87017763abae0cfe09d47987f5f6ac37c4f073d | refs/heads/master | 2021-03-12T22:15:47.889580 | 2009-04-17T13:29:39 | 2009-04-17T13:29:39 | 178,477 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,232 | h | // Magic Software, Inc.
// http://www.magic-software.com
// http://www.wild-magic.com
// Copyright (c) 2003. All Rights Reserved
//
// The Wild Magic Library (WML) source code is supplied under the terms of
// the license agreement http://www.magic-software.com/License/WildMagic.pdf
// and may not be copied or disclosed except in accordance with the terms of
// that agreement.
#ifndef WMLDLODNODE_H
#define WMLDLODNODE_H
#include "WmlSwitchNode.h"
#include <vector>
namespace Wml
{
class Camera;
class WML_ITEM DlodNode : public SwitchNode
{
WmlDeclareRTTI;
WmlDeclareStream;
public:
// construction
DlodNode (int iQuantity = 1, int iGrowBy = 1);
// center for level of detail
Vector3f& ModelCenter ();
const Vector3f& ModelCenter () const;
const Vector3f& WorldCenter () const;
// distance intervals for children
void SetModelMinSqrDistance (int i, float fMinSqrDist);
void SetModelMaxSqrDistance (int i, float fMaxSqrDist);
void SetModelSqrDistance (int i, float fMinSqrDist, float fMaxSqrDist);
float GetModelMinSqrDistance (int i) const;
float GetModelMaxSqrDistance (int i) const;
void GetModelSqrDistance (int i, float& rfMinSqrDist,
float& rfMaxSqrDist) const;
float GetWorldMinSqrDistance (int i) const;
float GetWorldMaxSqrDistance (int i) const;
void GetWorldSqrDistance (int i, float& rfMinSqrDist,
float& rfMaxSqrDist) const;
protected:
// geometric updates
void SelectLevelOfDetail (const Camera* pkCamera);
virtual void UpdateWorldData (float fAppTime);
// drawing
virtual void Draw (Renderer& rkRenderer);
// for deferred updates
float m_fLastUpdateTime;
// point whose distance to camera determines correct child
Vector3f m_kModelLodCenter;
Vector3f m_kWorldLodCenter;
// squared distances for each LOD interval
std::vector<float> m_afModelMinSqrDist;
std::vector<float> m_afModelMaxSqrDist;
std::vector<float> m_afWorldMinSqrDist;
std::vector<float> m_afWorldMaxSqrDist;
};
WmlSmartPointer(DlodNode);
WmlRegisterStream(DlodNode);
#include "WmlDlodNode.inl"
}
#endif
| [
"[email protected]"
] | [
[
[
1,
79
]
]
] |
ac42b37194a914c15d316f4c74747599bd87bdf9 | b14d5833a79518a40d302e5eb40ed5da193cf1b2 | /cpp/extern/xercesc++/2.6.0/samples/DOMPrint/DOMPrintErrorHandler.hpp | 8fbda56d4f42b142a1100b0a8a6c322a82c70211 | [
"Apache-2.0"
] | permissive | andyburke/bitflood | dcb3fb62dad7fa5e20cf9f1d58aaa94be30e82bf | fca6c0b635d07da4e6c7fbfa032921c827a981d6 | refs/heads/master | 2016-09-10T02:14:35.564530 | 2011-11-17T09:51:49 | 2011-11-17T09:51:49 | 2,794,411 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,620 | hpp | /*
* Copyright 2002,2004 The Apache Software Foundation.
*
* 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.
*/
/*
* $Id: DOMPrintErrorHandler.hpp,v 1.3 2004/09/08 13:55:31 peiyongz Exp $
* $Log: DOMPrintErrorHandler.hpp,v $
* Revision 1.3 2004/09/08 13:55:31 peiyongz
* Apache License Version 2.0
*
* Revision 1.2 2002/11/05 21:46:19 tng
* Explicit code using namespace in application.
*
* Revision 1.1 2002/05/29 21:19:50 peiyongz
* DOM3 DOMWriter/DOMWriterFilter
*
*
*/
#ifndef DOM_PRINT_ERROR_HANDLER_HPP
#define DOM_PRINT_ERROR_HANDLER_HPP
#include <xercesc/dom/DOMErrorHandler.hpp>
XERCES_CPP_NAMESPACE_USE
class DOMPrintErrorHandler : public DOMErrorHandler
{
public:
DOMPrintErrorHandler(){};
~DOMPrintErrorHandler(){};
/** @name The error handler interface */
bool handleError(const DOMError& domError);
void resetErrors(){};
private :
/* Unimplemented constructors and operators */
DOMPrintErrorHandler(const DOMErrorHandler&);
void operator=(const DOMErrorHandler&);
};
#endif
| [
"[email protected]"
] | [
[
[
1,
58
]
]
] |
0ba5e261fed7b688c7b795ef247a69d8d68f77b3 | 555ce7f1e44349316e240485dca6f7cd4496ea9c | /DirectShowFilters/TsWriter/source/DiskRecorder.h | 60e4d836d5cd61918292fa6bf7c3cbda32106f57 | [] | no_license | Yura80/MediaPortal-1 | c71ce5abf68c70852d261bed300302718ae2e0f3 | 5aae402f5aa19c9c3091c6d4442b457916a89053 | refs/heads/master | 2021-04-15T09:01:37.267793 | 2011-11-25T20:02:53 | 2011-11-25T20:11:02 | 2,851,405 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,672 | h | /*
* Copyright (C) 2006-2008 Team MediaPortal
* http://www.team-mediaportal.com
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
#include "multifilewriter.h"
#include "criticalsection.h"
#include "entercriticalsection.h"
#include "..\..\shared\TsHeader.h"
#include "..\..\shared\adaptionfield.h"
#include "..\..\shared\pcr.h"
#include "videoaudioobserver.h"
#include "PmtParser.h"
#include <vector>
#include <map>
using namespace std;
using namespace Mediaportal;
// Incremental buffer sizes
#define NUMBER_THROTTLE_BUFFER_SIZES 20
//* enum which specified the timeshifting mode
enum RecordingMode
{
TimeShift=0,
Recording=1
};
//* enum which specified the pid type
enum PidType
{
Video=0,
Audio=1,
Other=2
};
enum ChannelType
{
TV = 0,
Radio = 1,
};
typedef struct stLastPtsDtsRecord
{
__int64 m_prevPts ;
__int64 m_prevDts ;
DWORD m_prevPtsTimeStamp ;
DWORD m_prevDtsTimeStamp ;
__int64 m_PtsCompensation ;
__int64 m_DtsCompensation ;
int m_Pid ;
} LastPtsDtsRecord;
class IFileWriter
{
public:
virtual void Write(byte* buffer, int len)=0;
};
class CDiskRecorder: public IFileWriter
{
public:
CDiskRecorder(RecordingMode mode);
~CDiskRecorder(void);
void SetFileNameW(wchar_t* pwszFileName);
void SetChannelType(int channelType);
bool Start();
void Stop();
void Pause( BYTE onOff) ;
void Reset();
void GetRecordingMode(int *mode) ;
void SetPmtPid(int pmtPid,int serviceId,byte* pmtData,int pmtLength);
// Only needed for timeshifting
void SetVideoAudioObserver (IVideoAudioObserver* callback);
void GetBufferSize( long * size) ;
void GetNumbFilesAdded( WORD *numbAdd) ;
void GetNumbFilesRemoved( WORD *numbRem) ;
void GetCurrentFileId( WORD *fileID) ;
void GetMinTSFiles( WORD *minFiles) ;
void SetMinTSFiles( WORD minFiles) ;
void GetMaxTSFiles( WORD *maxFiles) ;
void SetMaxTSFiles( WORD maxFiles) ;
void GetMaxTSFileSize( __int64 *maxSize) ;
void SetMaxTSFileSize( __int64 maxSize) ;
void GetChunkReserve( __int64 *chunkSize) ;
void SetChunkReserve( __int64 chunkSize) ;
void GetFileBufferSize( __int64 *lpllsize) ;
void GetTimeShiftPosition(__int64 * position,long * bufferId);
void GetDiscontinuityCounter(int* counter);
void GetTotalBytes(int* packetsProcessed);
void OnTsPacket(byte* tsPacket);
void Write(byte* buffer, int len);
private:
void WriteToRecording(byte* buffer, int len);
void WriteToTimeshiftFile(byte* buffer, int len);
void WriteLog(const char *fmt, ...);
void WriteLog(const wchar_t *fmt, ...);
void SetPcrPid(int pcrPid);
bool IsStreamWanted(int stream_type);
void AddStream(PidInfo2 pidInfo);
void Flush();
void WriteTs(byte* tsPacket);
void WriteFakePAT();
void WriteFakePMT();
__int64 EcPcrTime(__int64 New, __int64 Prev) ;
void PatchPcr(byte* tsPacket,CTsHeader& header);
void PatchPtsDts(byte* tsPacket,CTsHeader& header,PidInfo2& pidInfo);
MultiFileWriterParam m_params;
RecordingMode m_recordingMode;
CPmtParser* m_pPmtParser;
bool m_bRunning;
wchar_t m_wszFileName[2048];
MultiFileWriter* m_pTimeShiftFile;
HANDLE m_hFile;
CCriticalSection m_section;
int m_iPmtPid;
int m_pcrPid;
int m_iServiceId;
vector<PidInfo2> m_vecPids;
// bool m_bSeenAudioStart;
bool m_AudioOrVideoSeen;
int m_iPmtContinuityCounter;
int m_iPatContinuityCounter;
int m_iTsContinuityCounter;
BOOL m_bPaused;
bool m_bDetermineNewStartPcr;
bool m_bStartPcrFound;
int m_iPacketCounter;
int m_iPatVersion;
int m_iPmtVersion;
int m_iPart;
byte* m_pWriteBuffer;
int m_iWriteBufferPos;
int m_iWriteBufferSize;
int m_iThrottleBufferSizes[NUMBER_THROTTLE_BUFFER_SIZES];
int m_iWriteBufferThrottle;
BOOL m_bThrottleAtMax;
ChannelType m_eChannelType;
CTsHeader m_tsHeader;
CAdaptionField m_adaptionField;
CPcr m_prevPcr;
int m_JumpInProgress; // Jump detected, wait confirmation
float m_PcrSpeed; // Time average between PCR samples
__int64 m_PcrCompensation; // Compensation from PCR/PTS/DTS to fake PCR/PTS/DTS ( 33 bits offset with PCR resoluion )
__int64 m_PcrFutureCompensation; // Future compensation computed during jump detection.
DWORD m_prevTimeStamp; // TimeStamp of last PCR patching.
bool m_bClearTsQueue;
unsigned long m_TsPacketCount;
vector <LastPtsDtsRecord> m_mapLastPtsDts;
typedef vector<LastPtsDtsRecord>::iterator imapLastPtsDts;
IVideoAudioObserver *m_pVideoAudioObserver;
};
| [
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]",
"[email protected]"
] | [
[
[
1,
35
],
[
41,
55
],
[
62,
63
],
[
71,
84
],
[
87,
110
],
[
113,
120
],
[
122,
129
],
[
131,
131
],
[
133,
137
],
[
139,
145
],
[
148,
149
],
[
151,
157
],
[
159,
160
],
[
166,
168
],
[
175,
177
],
[
182,
183
]
],
[
[
36,
40
],
[
56,
61
],
[
86,
86
],
[
161,
165
]
],
[
[
64,
70
],
[
130,
130
],
[
132,
132
],
[
146,
147
],
[
169,
169
],
[
178,
181
]
],
[
[
85,
85
],
[
121,
121
],
[
138,
138
]
],
[
[
111,
112
],
[
150,
150
],
[
158,
158
],
[
170,
174
]
]
] |
35a3c240a480790ab61cfd2e0b009439b6e03702 | 3cad09dde08a7f9f4fe4acbcb2ffd4643a642957 | /opencv/win/interfaces/swig/python/_cv_win32.cpp | d2d9268401068808e14d8c5f6734988cbbbc159e | [] | no_license | gmarcotte/cos436-eye-tracker | 420ad9c37cf1819a238c0379662dee71f6fd9b0f | 05d0b010bae8dcf06add2ae93534851668d4eff4 | refs/heads/master | 2021-01-23T13:47:38.533817 | 2009-01-15T02:40:43 | 2009-01-15T02:40:43 | 32,219,880 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,937,887 | cpp | /* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
* changes to this file unless you know what you are doing--modify the SWIG
* interface file instead.
* ----------------------------------------------------------------------------- */
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#ifdef __cplusplus
template<typename T> class SwigValueWrapper {
T *tt;
public:
SwigValueWrapper() : tt(0) { }
SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
SwigValueWrapper(const T& t) : tt(new T(t)) { }
~SwigValueWrapper() { delete tt; }
SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
operator T&() const { return *tt; }
T *operator&() { return tt; }
private:
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
template <typename T> T SwigValueInit() {
return T();
}
#endif
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
* ----------------------------------------------------------------------------- */
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
# define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
# define SWIGTEMPLATEDISAMBIGUATOR template
# else
# define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
# define SWIGINLINE inline
# else
# define SWIGINLINE
# endif
#endif
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# ifndef GCC_HASCLASSVISIBILITY
# define GCC_HASCLASSVISIBILITY
# endif
#endif
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# if defined(STATIC_LINKED)
# define SWIGEXPORT
# else
# define SWIGEXPORT __declspec(dllexport)
# endif
# else
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
# define SWIGEXPORT __attribute__ ((visibility("default")))
# else
# define SWIGEXPORT
# endif
# endif
#endif
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
/* Python.h has to appear first */
#include <Python.h>
/* -----------------------------------------------------------------------------
* swigrun.swg
*
* This file contains generic CAPI SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
/* This should only be incremented when either the layout of swig_type_info changes,
or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
creating a static or dynamic library from the swig runtime code.
In 99.9% of the cases, swig just needs to declare them as 'static'.
But only do this if is strictly necessary, ie, if you have problems
with your compiler or so.
*/
#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif
#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif
/* Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
/*
Flags/methods for returning states.
The swig conversion methods, as ConvertPtr, return and integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
Use the following macros/flags to set or process the returning
states.
In old swig versions, you usually write code as:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
} else {
//fail code
}
Now you can be more explicit as:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
// success code
} else {
// fail code
}
that seems to be the same, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
if (SWIG_IsOK(res)) {
// success code
if (SWIG_IsNewObj(res) {
...
delete *ptr;
} else {
...
}
} else {
// fail code
}
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
requires also to SWIG_ConvertPtr to return new result values, as
int SWIG_ConvertPtr(obj, ptr,...) {
if (<obj is ok>) {
if (<need new object>) {
*ptr = <ptr to new allocated object>;
return SWIG_NEWOBJ;
} else {
*ptr = <ptr to old object>;
return SWIG_OLDOBJ;
}
} else {
return SWIG_BADOBJ;
}
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
swig errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
int food(double)
int fooi(int);
and you call
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
*/
#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ (SWIG_ERROR)
#define SWIG_OLDOBJ (SWIG_OK)
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
# define SWIG_TypeRank unsigned long
# endif
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
# define SWIG_MAXCASTRANK (2)
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
# define SWIG_AddCast
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);
/* Structure to store information on one type */
typedef struct swig_type_info {
const char *name; /* mangled name of this type */
const char *str; /* human readable name of this type */
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
void *clientdata; /* language specific type data */
int owndata; /* flag if the structure owns the clientdata */
} swig_type_info;
/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
swig_type_info *type; /* pointer to type that is equivalent to this type */
swig_converter_func converter; /* function to cast the void pointers */
struct swig_cast_info *next; /* pointer to next cast in linked list */
struct swig_cast_info *prev; /* pointer to the previous cast */
} swig_cast_info;
/* Structure used to store module information
* Each module generates one structure like this, and the runtime collects
* all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
size_t size; /* Number of types in this module */
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
swig_type_info **type_initial; /* Array of initially generated type structures */
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
void *clientdata; /* Language specific module data */
} swig_module_info;
/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
Return 0 when the two name types are equivalent, as in
strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
const char *f2, const char *l2) {
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
while ((*f1 == ' ') && (f1 != l1)) ++f1;
while ((*f2 == ' ') && (f2 != l2)) ++f2;
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
}
return (int)((l1 - f1) - (l2 - f2));
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
int equiv = 0;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (!equiv && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
if (*ne) ++ne;
}
return equiv;
}
/*
Check type equivalence in a name list like <name1>|<name2>|...
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCompare(const char *nb, const char *tb) {
int equiv = 0;
const char* te = tb + strlen(tb);
const char* ne = nb;
while (!equiv && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
if (*ne) ++ne;
}
return equiv;
}
/* think of this as a c++ template<> or a scheme macro */
#define SWIG_TypeCheck_Template(comparison, ty) \
if (ty) { \
swig_cast_info *iter = ty->cast; \
while (iter) { \
if (comparison) { \
if (iter == ty->cast) return iter; \
/* Move iter to the top of the linked list */ \
iter->prev->next = iter->next; \
if (iter->next) \
iter->next->prev = iter->prev; \
iter->next = ty->cast; \
iter->prev = 0; \
if (ty->cast) ty->cast->prev = iter; \
ty->cast = iter; \
return iter; \
} \
iter = iter->next; \
} \
} \
return 0
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
}
/* Same as previous function, except strcmp is replaced with a pointer comparison */
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
SWIG_TypeCheck_Template(iter->type == from, into);
}
/*
Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
swig_type_info *lastty = ty;
if (!ty || !ty->dcast) return ty;
while (ty && (ty->dcast)) {
ty = (*ty->dcast)(ptr);
if (ty) lastty = ty;
}
return lastty;
}
/*
Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
return ty->name;
}
/*
Return the pretty name associated with this type,
that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
/* The "str" field contains the equivalent pretty names of the
type, separated by vertical-bar characters. We choose
to print the last name, as it is often (?) the most
specific. */
if (!type) return NULL;
if (type->str != NULL) {
const char *last_name = type->str;
const char *s;
for (s = type->str; *s; s++)
if (*s == '|') last_name = s+1;
return last_name;
}
else
return type->name;
}
/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
}
cast = cast->next;
}
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
register size_t l = 0;
register size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
register size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
register int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
r = i - 1;
} else {
break;
}
} else if (compare > 0) {
l = i + 1;
}
} else {
break; /* should never happen */
}
} while (l <= r);
}
iter = iter->next;
} while (iter != end);
return 0;
}
/*
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
if (ret) {
return ret;
} else {
/* STEP 2: If the type hasn't been found, do a complete search
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
register size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
}
iter = iter->next;
} while (iter != end);
}
/* neither found a match */
return 0;
}
/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
register const unsigned char *u = (unsigned char *) ptr;
register const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
register unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
register unsigned char *u = (unsigned char *) ptr;
register const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
register char d = *(c++);
register unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
uu = ((d - ('a'-10)) << 4);
else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
uu |= (d - '0');
else if ((d >= 'a') && (d <= 'f'))
uu |= (d - ('a'-10));
else
return (char *) 0;
*u = uu;
}
return c;
}
/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
char *r = buff;
if ((2*sizeof(void *) + 2) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,&ptr,sizeof(void *));
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
strcpy(r,name);
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
*ptr = (void *) 0;
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sizeof(void *));
}
SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
char *r = buff;
size_t lname = (name ? strlen(name) : 0);
if ((2*sz + 2 + lname) > bsz) return 0;
*(r++) = '_';
r = SWIG_PackData(r,ptr,sz);
if (lname) {
strncpy(r,name,lname+1);
} else {
*r = 0;
}
return buff;
}
SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
if (*c != '_') {
if (strcmp(c,"NULL") == 0) {
memset(ptr,0,sz);
return name;
} else {
return 0;
}
}
return SWIG_UnpackData(++c,ptr,sz);
}
#ifdef __cplusplus
}
#endif
/* Errors in SWIG */
#define SWIG_UnknownError -1
#define SWIG_IOError -2
#define SWIG_RuntimeError -3
#define SWIG_IndexError -4
#define SWIG_TypeError -5
#define SWIG_DivisionByZero -6
#define SWIG_OverflowError -7
#define SWIG_SyntaxError -8
#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
# define PyOS_snprintf _snprintf
# else
# define PyOS_snprintf snprintf
# endif
#endif
/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000
#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif
static PyObject *
PyString_FromFormat(const char *fmt, ...) {
va_list ap;
char buf[SWIG_PYBUFFER_SIZE * 2];
int res;
va_start(ap, fmt);
res = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif
/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif
/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
# define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
# define PyObject_GenericGetAttr 0
# endif
#endif
/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
# define Py_NotImplemented PyExc_RuntimeError
# endif
#endif
/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif
/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
# define PySequence_Size PySequence_Length
# endif
#endif
/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
PyObject *result = ok ? Py_True : Py_False;
Py_INCREF(result);
return result;
}
#endif
/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
PyObject* type = 0;
switch(code) {
case SWIG_MemoryError:
type = PyExc_MemoryError;
break;
case SWIG_IOError:
type = PyExc_IOError;
break;
case SWIG_RuntimeError:
type = PyExc_RuntimeError;
break;
case SWIG_IndexError:
type = PyExc_IndexError;
break;
case SWIG_TypeError:
type = PyExc_TypeError;
break;
case SWIG_DivisionByZero:
type = PyExc_ZeroDivisionError;
break;
case SWIG_OverflowError:
type = PyExc_OverflowError;
break;
case SWIG_SyntaxError:
type = PyExc_SyntaxError;
break;
case SWIG_ValueError:
type = PyExc_ValueError;
break;
case SWIG_SystemError:
type = PyExc_SystemError;
break;
case SWIG_AttributeError:
type = PyExc_AttributeError;
break;
default:
type = PyExc_RuntimeError;
}
return type;
}
SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
PyErr_Clear();
Py_XINCREF(type);
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
PyErr_SetString(PyExc_RuntimeError, mesg);
}
}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
# undef SWIG_PYTHON_THREADS
# endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
# define SWIG_PYTHON_USE_GIL
# endif
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
# endif
# ifdef __cplusplus /* C++ code */
class SWIG_Python_Thread_Block {
bool status;
PyGILState_STATE state;
public:
void end() { if (status) { PyGILState_Release(state); status = false;} }
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
~SWIG_Python_Thread_Block() { end(); }
};
class SWIG_Python_Thread_Allow {
bool status;
PyThreadState *save;
public:
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
~SWIG_Python_Thread_Allow() { end(); }
};
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
# else /* C code */
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
# endif
# else /* Old thread way, not implemented, user must provide it */
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
# define SWIG_PYTHON_INITIALIZE_THREADS
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
# define SWIG_PYTHON_THREAD_END_BLOCK
# endif
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# endif
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
# define SWIG_PYTHON_THREAD_END_ALLOW
# endif
# endif
#else /* No thread support */
# define SWIG_PYTHON_INITIALIZE_THREADS
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
# define SWIG_PYTHON_THREAD_END_BLOCK
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
# define SWIG_PYTHON_THREAD_END_ALLOW
#endif
/* -----------------------------------------------------------------------------
* Python API portion that goes into the runtime
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* cc-mode */
#endif
#endif
/* -----------------------------------------------------------------------------
* Constant declarations
* ----------------------------------------------------------------------------- */
/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY 5
/* Constant information structure */
typedef struct swig_const_info {
int type;
char *name;
long lvalue;
double dvalue;
void *pvalue;
swig_type_info **ptype;
} swig_const_info;
#ifdef __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#endif
/* -----------------------------------------------------------------------------
* See the LICENSE file for information on copyright, usage and redistribution
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
*
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, (char *) msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, (char*) name, obj);
Py_DECREF(obj);
}
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
PyList_SetItem(result, 0, o2);
}
PyList_Append(result,obj);
Py_DECREF(obj);
}
return result;
#else
PyObject* o2;
PyObject* o3;
if (!result) {
result = obj;
} else if (result == Py_None) {
Py_DECREF(result);
result = obj;
} else {
if (!PyTuple_Check(result)) {
o2 = result;
result = PyTuple_New(1);
PyTuple_SET_ITEM(result, 0, o2);
}
o3 = PyTuple_New(1);
PyTuple_SET_ITEM(o3, 0, obj);
o2 = result;
result = PySequence_Concat(o2, o3);
Py_DECREF(o2);
Py_DECREF(o3);
}
return result;
#endif
}
/* Unpack the argument tuple */
SWIGINTERN int
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
register Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
register int i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
#endif
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#ifdef __cplusplus
extern "C" {
#if 0
} /* cc-mode */
#endif
#endif
/* How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
# ifndef SWIG_PYTHON_NO_BUILD_NONE
# ifndef SWIG_PYTHON_BUILD_NONE
# define SWIG_PYTHON_BUILD_NONE
# endif
# endif
#endif
#ifdef SWIG_PYTHON_BUILD_NONE
# ifdef Py_None
# undef Py_None
# define Py_None SWIG_Py_None()
# endif
SWIGRUNTIMEINLINE PyObject *
_SWIG_Py_None(void)
{
PyObject *none = Py_BuildValue((char*)"");
Py_DECREF(none);
return none;
}
SWIGRUNTIME PyObject *
SWIG_Py_None(void)
{
static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
return none;
}
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
Py_INCREF(none);
return none;
}
/* PySwigClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
} PySwigClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
PySwigClientData *data = (PySwigClientData *)ty->clientdata;
return data ? data->implicitconv : 0;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME PySwigClientData *
PySwigClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyClass_Check(obj)) {
data->newraw = 0;
data->newargs = obj;
Py_INCREF(obj);
} else {
#if (PY_VERSION_HEX < 0x02020000)
data->newraw = 0;
#else
data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
#endif
if (data->newraw) {
Py_INCREF(data->newraw);
data->newargs = PyTuple_New(1);
PyTuple_SetItem(data->newargs, 0, obj);
} else {
data->newargs = obj;
}
Py_INCREF(data->newargs);
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
int flags;
Py_INCREF(data->destroy);
flags = PyCFunction_GET_FLAGS(data->destroy);
#ifdef METH_O
data->delargs = !(flags & (METH_O));
#else
data->delargs = 0;
#endif
} else {
data->delargs = 0;
}
data->implicitconv = 0;
return data;
}
}
SWIGRUNTIME void
PySwigClientData_Del(PySwigClientData* data)
{
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
}
/* =============== PySwigObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
} PySwigObject;
SWIGRUNTIME PyObject *
PySwigObject_long(PySwigObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
PySwigObject_format(const char* fmt, PySwigObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
PyObject *ofmt = PyString_FromString(fmt);
if (ofmt) {
res = PyString_Format(ofmt,args);
Py_DECREF(ofmt);
}
Py_DECREF(args);
}
}
return res;
}
SWIGRUNTIME PyObject *
PySwigObject_oct(PySwigObject *v)
{
return PySwigObject_format("%o",v);
}
SWIGRUNTIME PyObject *
PySwigObject_hex(PySwigObject *v)
{
return PySwigObject_format("%x",v);
}
SWIGRUNTIME PyObject *
#ifdef METH_NOARGS
PySwigObject_repr(PySwigObject *v)
#else
PySwigObject_repr(PySwigObject *v, PyObject *args)
#endif
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *hex = PySwigObject_hex(v);
PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
Py_DECREF(hex);
if (v->next) {
#ifdef METH_NOARGS
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
#else
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
#endif
PyString_ConcatAndDel(&repr,nrep);
}
return repr;
}
SWIGRUNTIME int
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
#ifdef METH_NOARGS
PyObject *repr = PySwigObject_repr(v);
#else
PyObject *repr = PySwigObject_repr(v, NULL);
#endif
if (repr) {
fputs(PyString_AsString(repr), fp);
Py_DECREF(repr);
return 0;
} else {
return 1;
}
}
SWIGRUNTIME PyObject *
PySwigObject_str(PySwigObject *v)
{
char result[SWIG_BUFFER_SIZE];
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
PyString_FromString(result) : 0;
}
SWIGRUNTIME int
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
SWIGRUNTIME PyTypeObject*
PySwigObject_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
return type;
}
SWIGRUNTIMEINLINE int
PySwigObject_Check(PyObject *op) {
return ((op)->ob_type == PySwigObject_type())
|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
}
SWIGRUNTIME PyObject *
PySwigObject_New(void *ptr, swig_type_info *ty, int own);
SWIGRUNTIME void
PySwigObject_dealloc(PyObject *v)
{
PySwigObject *sobj = (PySwigObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
if (data->delargs) {
/* we need to create a temporal object to carry the destroy operation */
PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
res = SWIG_Python_CallFunctor(destroy, tmp);
Py_DECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
}
Py_XDECREF(next);
PyObject_DEL(v);
}
SWIGRUNTIME PyObject*
PySwigObject_append(PyObject* v, PyObject* next)
{
PySwigObject *sobj = (PySwigObject *) v;
#ifndef METH_O
PyObject *tmp = 0;
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
next = tmp;
#endif
if (!PySwigObject_Check(next)) {
return NULL;
}
sobj->next = next;
Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
#ifdef METH_NOARGS
PySwigObject_next(PyObject* v)
#else
PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
PySwigObject *sobj = (PySwigObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
PySwigObject_disown(PyObject *v)
#else
PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
PySwigObject *sobj = (PySwigObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
#ifdef METH_NOARGS
PySwigObject_acquire(PyObject *v)
#else
PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
#endif
{
PySwigObject *sobj = (PySwigObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
PySwigObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#else
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
#endif
{
return NULL;
}
else
{
PySwigObject *sobj = (PySwigObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
#ifdef METH_NOARGS
if (PyObject_IsTrue(val)) {
PySwigObject_acquire(v);
} else {
PySwigObject_disown(v);
}
#else
if (PyObject_IsTrue(val)) {
PySwigObject_acquire(v,args);
} else {
PySwigObject_disown(v,args);
}
#endif
}
return obj;
}
}
#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#else
static PyMethodDef
swigobject_methods[] = {
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
{(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
{(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
{0, 0, 0, 0}
};
#endif
#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
PySwigObject_getattr(PySwigObject *sobj,char *name)
{
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif
SWIGRUNTIME PyTypeObject*
_PySwigObject_type(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
static PyNumberMethods PySwigObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
(binaryfunc)0, /*nb_divide*/
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
(coercion)0, /*nb_coerce*/
(unaryfunc)PySwigObject_long, /*nb_int*/
(unaryfunc)PySwigObject_long, /*nb_long*/
(unaryfunc)0, /*nb_float*/
(unaryfunc)PySwigObject_oct, /*nb_oct*/
(unaryfunc)PySwigObject_hex, /*nb_hex*/
#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
};
static PyTypeObject pyswigobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp
= {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
(char *)"PySwigObject", /* tp_name */
sizeof(PySwigObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)PySwigObject_dealloc, /* tp_dealloc */
(printfunc)PySwigObject_print, /* tp_print */
#if PY_VERSION_HEX < 0x02020000
(getattrfunc)PySwigObject_getattr, /* tp_getattr */
#else
(getattrfunc)0, /* tp_getattr */
#endif
(setattrfunc)0, /* tp_setattr */
(cmpfunc)PySwigObject_compare, /* tp_compare */
(reprfunc)PySwigObject_repr, /* tp_repr */
&PySwigObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)PySwigObject_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigobject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0, /* tp_iter */
0, /* tp_iternext */
swigobject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
pyswigobject_type = tmp;
pyswigobject_type.ob_type = &PyType_Type;
type_init = 1;
}
return &pyswigobject_type;
}
SWIGRUNTIME PyObject *
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
{
PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} PySwigPacked;
SWIGRUNTIME int
PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
char result[SWIG_BUFFER_SIZE];
fputs("<Swig Packed ", fp);
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
fputs("at ", fp);
fputs(result, fp);
}
fputs(v->ty->name,fp);
fputs(">", fp);
return 0;
}
SWIGRUNTIME PyObject *
PySwigPacked_repr(PySwigPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
PySwigPacked_str(PySwigPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return PyString_FromFormat("%s%s", result, v->ty->name);
} else {
return PyString_FromString(v->ty->name);
}
}
SWIGRUNTIME int
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
SWIGRUNTIME PyTypeObject*
PySwigPacked_type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
return type;
}
SWIGRUNTIMEINLINE int
PySwigPacked_Check(PyObject *op) {
return ((op)->ob_type == _PySwigPacked_type())
|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
}
SWIGRUNTIME void
PySwigPacked_dealloc(PyObject *v)
{
if (PySwigPacked_Check(v)) {
PySwigPacked *sobj = (PySwigPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
_PySwigPacked_type(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
static PyTypeObject pyswigpacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp
= {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
(char *)"PySwigPacked", /* tp_name */
sizeof(PySwigPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)PySwigPacked_dealloc, /* tp_dealloc */
(printfunc)PySwigPacked_print, /* tp_print */
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
(cmpfunc)PySwigPacked_compare, /* tp_compare */
(reprfunc)PySwigPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)PySwigPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
swigpacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
pyswigpacked_type = tmp;
pyswigpacked_type.ob_type = &PyType_Type;
type_init = 1;
}
return &pyswigpacked_type;
}
SWIGRUNTIME PyObject *
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_DEL((PyObject *) sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (PySwigPacked_Check(obj)) {
PySwigPacked *sobj = (PySwigPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
return PyString_FromString("this");
}
SWIGRUNTIME PyObject *
SWIG_This(void)
{
static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
return swig_this;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
SWIGRUNTIME PySwigObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
if (PySwigObject_Check(pyobj)) {
return (PySwigObject *) pyobj;
} else {
PyObject *obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !PySwigObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
PySwigObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (PySwigObject *)obj;
}
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
if (!obj) return SWIG_ERROR;
if (obj == Py_None) {
if (ptr) *ptr = 0;
return SWIG_OK;
} else {
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (PySwigObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own);
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
return SWIG_OK;
} else {
int res = SWIG_ERROR;
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
Py_DECREF(impconv);
}
}
}
}
return res;
}
}
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
/* here we get the method pointer for callbacks */
const char *doc = (char*)(((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc) {
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
if (!desc) return SWIG_ERROR;
}
if (ty) {
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
} else {
*ptr = vptr;
}
return SWIG_OK;
}
}
/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, whitout calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
PyDict_SetItem(dict, SWIG_This(), swig_this);
}
}
#else
PyObject *key = SWIG_This();
PyObject_SetAttr(inst, key, swig_this);
#endif
}
} else {
PyObject *dict = PyDict_New();
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
}
return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
PyObject *inst;
PyObject *dict = PyDict_New();
PyDict_SetItem(dict, SWIG_This(), swig_this);
inst = PyInstance_NewRaw(data->newargs, dict);
Py_DECREF(dict);
return (PyObject *) inst;
#else
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
if (inst == NULL) {
return NULL;
}
inst->in_class = (PyClassObject *)data->newargs;
Py_INCREF(inst->in_class);
inst->in_dict = PyDict_New();
if (inst->in_dict == NULL) {
Py_DECREF(inst);
return NULL;
}
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
PyObject_GC_Init(inst);
#endif
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
return (PyObject *) inst;
#endif
#endif
}
SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
PyObject *dict;
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
dict = *dictptr;
if (dict == NULL) {
dict = PyDict_New();
*dictptr = dict;
}
PyDict_SetItem(dict, SWIG_This(), swig_this);
return;
}
#endif
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
PyDict_SetItem(dict, SWIG_This(), swig_this);
Py_DECREF(dict);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
return NULL;
} else {
PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
PySwigObject_append((PyObject*) sthis, obj[1]);
} else {
SWIG_Python_SetSwigThis(obj[0], obj[1]);
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
if (!ptr) {
return SWIG_Py_Void();
} else {
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
PyObject *robj = PySwigObject_New(ptr, type, own);
PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
if (inst) {
Py_DECREF(robj);
robj = inst;
}
}
return robj;
}
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void) {
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
}
return (swig_module_info *) type_pointer;
}
#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0. The following function
is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
PyObject *dict;
if (!PyModule_Check(m)) {
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs module as first arg");
return SWIG_ERROR;
}
if (!o) {
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs non-NULL value");
return SWIG_ERROR;
}
dict = PyModule_GetDict(m);
if (dict == NULL) {
/* Internal error -- modules must have a dict! */
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
PyModule_GetName(m));
return SWIG_ERROR;
}
if (PyDict_SetItemString(dict, name, o))
return SWIG_ERROR;
Py_DECREF(o);
return SWIG_OK;
}
#endif
SWIGRUNTIME void
SWIG_Python_DestroyModule(void *vptr)
{
swig_module_info *swig_module = (swig_module_info *) vptr;
swig_type_info **types = swig_module->types;
size_t i;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
PySwigClientData *data = (PySwigClientData *) ty->clientdata;
if (data) PySwigClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
swig_empty_runtime_method_table);
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
if (pointer && module) {
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
} else {
Py_XDECREF(pointer);
}
}
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
return cache;
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
PyObject *key = PyString_FromString(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
} else {
swig_module_info *swig_module = SWIG_Python_GetModule();
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCObject_FromVoidPtr(descriptor, NULL);
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
}
Py_DECREF(key);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
} else {
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
}
Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
PySwigObject_GetDesc(PyObject *self)
{
PySwigObject *v = (PySwigObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : (char*)"";
}
SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
if (obj && PySwigObject_Check(obj)) {
const char *otype = (const char *) PySwigObject_GetDesc(obj);
if (otype) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
type, otype);
return;
}
} else
#endif
{
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? PyString_AsString(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
}
Py_XDECREF(str);
return;
}
}
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
} else {
PyErr_Format(PyExc_TypeError, "unexpected type is received");
}
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
if (flags & SWIG_POINTER_EXCEPTION) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
}
}
return result;
}
#ifdef __cplusplus
#if 0
{ /* cc-mode */
#endif
}
#endif
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
#undef PyAPI_FUNC
/* define the PyAPI_FUNC macro if it doesn't exist, for example with Python
version below 2.3... But not really tested... */
#ifndef PyAPI_FUNC
# define PyAPI_FUNC(RTYPE) RTYPE
#endif
/* remove the PyInt_AS_LONG if defined, as this cause problems on RedHat */
#ifdef PyInt_AS_LONG
#undef PyInt_AS_LONG
#endif
/* wrapper to the better function PyInt_AsLong, removing problems
with RedHat (I hope) */
static PyAPI_FUNC(long) PyInt_AS_LONG (PyObject *obj) {
return PyInt_AsLong (obj);
}
/* remove the PyFloat_AS_DOUBLE if defined, to prevent errors */
#ifdef PyFloat_AS_DOUBLE
#undef PyFloat_AS_DOUBLE
#endif
/* wrapper to the better function PyFloat_AS_DOUBLE, to prevent errors */
static PyAPI_FUNC(double) PyFloat_AS_DOUBLE (PyObject *obj) {
return PyFloat_AsDouble (obj);
}
#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
/* -------- TYPES TABLE (BEGIN) -------- */
#define SWIGTYPE_p_Cv32suf swig_types[0]
#define SWIGTYPE_p_Cv64suf swig_types[1]
#define SWIGTYPE_p_CvAttrList swig_types[2]
#define SWIGTYPE_p_CvAvgComp swig_types[3]
#define SWIGTYPE_p_CvBaseImageFilter swig_types[4]
#define SWIGTYPE_p_CvBox2D swig_types[5]
#define SWIGTYPE_p_CvBoxFilter swig_types[6]
#define SWIGTYPE_p_CvChain swig_types[7]
#define SWIGTYPE_p_CvChainPtReader swig_types[8]
#define SWIGTYPE_p_CvConDensation swig_types[9]
#define SWIGTYPE_p_CvConnectedComp swig_types[10]
#define SWIGTYPE_p_CvContour swig_types[11]
#define SWIGTYPE_p_CvContourTree swig_types[12]
#define SWIGTYPE_p_CvConvexityDefect swig_types[13]
#define SWIGTYPE_p_CvFeatureTree swig_types[14]
#define SWIGTYPE_p_CvFileNode swig_types[15]
#define SWIGTYPE_p_CvFileNode_data swig_types[16]
#define SWIGTYPE_p_CvFileStorage swig_types[17]
#define SWIGTYPE_p_CvFilter swig_types[18]
#define SWIGTYPE_p_CvFont swig_types[19]
#define SWIGTYPE_p_CvGenericHash swig_types[20]
#define SWIGTYPE_p_CvGraph swig_types[21]
#define SWIGTYPE_p_CvGraphEdge swig_types[22]
#define SWIGTYPE_p_CvGraphScanner swig_types[23]
#define SWIGTYPE_p_CvGraphVtx swig_types[24]
#define SWIGTYPE_p_CvGraphVtx2D swig_types[25]
#define SWIGTYPE_p_CvHaarClassifier swig_types[26]
#define SWIGTYPE_p_CvHaarClassifierCascade swig_types[27]
#define SWIGTYPE_p_CvHaarFeature swig_types[28]
#define SWIGTYPE_p_CvHaarFeature_rect swig_types[29]
#define SWIGTYPE_p_CvHaarStageClassifier swig_types[30]
#define SWIGTYPE_p_CvHidHaarClassifierCascade swig_types[31]
#define SWIGTYPE_p_CvHistogram swig_types[32]
#define SWIGTYPE_p_CvHuMoments swig_types[33]
#define SWIGTYPE_p_CvImage swig_types[34]
#define SWIGTYPE_p_CvKalman swig_types[35]
#define SWIGTYPE_p_CvLaplaceFilter swig_types[36]
#define SWIGTYPE_p_CvLevMarq swig_types[37]
#define SWIGTYPE_p_CvLineIterator swig_types[38]
#define SWIGTYPE_p_CvLinearFilter swig_types[39]
#define SWIGTYPE_p_CvMat swig_types[40]
#define SWIGTYPE_p_CvMatND swig_types[41]
#define SWIGTYPE_p_CvMatND_data swig_types[42]
#define SWIGTYPE_p_CvMatND_dim swig_types[43]
#define SWIGTYPE_p_CvMat_data swig_types[44]
#define SWIGTYPE_p_CvMatrix swig_types[45]
#define SWIGTYPE_p_CvMatrix3 swig_types[46]
#define SWIGTYPE_p_CvMemBlock swig_types[47]
#define SWIGTYPE_p_CvMemStorage swig_types[48]
#define SWIGTYPE_p_CvMemStoragePos swig_types[49]
#define SWIGTYPE_p_CvModule swig_types[50]
#define SWIGTYPE_p_CvModuleInfo swig_types[51]
#define SWIGTYPE_p_CvMoments swig_types[52]
#define SWIGTYPE_p_CvMorphology swig_types[53]
#define SWIGTYPE_p_CvNArrayIterator swig_types[54]
#define SWIGTYPE_p_CvNextEdgeType swig_types[55]
#define SWIGTYPE_p_CvPOSITObject swig_types[56]
#define SWIGTYPE_p_CvPluginFuncInfo swig_types[57]
#define SWIGTYPE_p_CvPoint swig_types[58]
#define SWIGTYPE_p_CvPoint2D32f swig_types[59]
#define SWIGTYPE_p_CvPoint2D64f swig_types[60]
#define SWIGTYPE_p_CvPoint3D32f swig_types[61]
#define SWIGTYPE_p_CvPoint3D64f swig_types[62]
#define SWIGTYPE_p_CvQuadEdge2D swig_types[63]
#define SWIGTYPE_p_CvRNG_Wrapper swig_types[64]
#define SWIGTYPE_p_CvRandState swig_types[65]
#define SWIGTYPE_p_CvRect swig_types[66]
#define SWIGTYPE_p_CvSURFParams swig_types[67]
#define SWIGTYPE_p_CvSURFPoint swig_types[68]
#define SWIGTYPE_p_CvScalar swig_types[69]
#define SWIGTYPE_p_CvSepFilter swig_types[70]
#define SWIGTYPE_p_CvSeq swig_types[71]
#define SWIGTYPE_p_CvSeqBlock swig_types[72]
#define SWIGTYPE_p_CvSeqReader swig_types[73]
#define SWIGTYPE_p_CvSeqWriter swig_types[74]
#define SWIGTYPE_p_CvSet swig_types[75]
#define SWIGTYPE_p_CvSetElem swig_types[76]
#define SWIGTYPE_p_CvSize swig_types[77]
#define SWIGTYPE_p_CvSize2D32f swig_types[78]
#define SWIGTYPE_p_CvSlice swig_types[79]
#define SWIGTYPE_p_CvSparseMat swig_types[80]
#define SWIGTYPE_p_CvSparseMatIterator swig_types[81]
#define SWIGTYPE_p_CvSparseNode swig_types[82]
#define SWIGTYPE_p_CvStereoBMState swig_types[83]
#define SWIGTYPE_p_CvStereoGCState swig_types[84]
#define SWIGTYPE_p_CvString swig_types[85]
#define SWIGTYPE_p_CvStringHashNode swig_types[86]
#define SWIGTYPE_p_CvSubdiv2D swig_types[87]
#define SWIGTYPE_p_CvSubdiv2DEdge_Wrapper swig_types[88]
#define SWIGTYPE_p_CvSubdiv2DPoint swig_types[89]
#define SWIGTYPE_p_CvSubdiv2DPointLocation swig_types[90]
#define SWIGTYPE_p_CvTermCriteria swig_types[91]
#define SWIGTYPE_p_CvTreeNodeIterator swig_types[92]
#define SWIGTYPE_p_CvTupleT_CvPoint_2_t swig_types[93]
#define SWIGTYPE_p_CvTupleT_float_2_t swig_types[94]
#define SWIGTYPE_p_CvTupleT_float_3_t swig_types[95]
#define SWIGTYPE_p_CvType swig_types[96]
#define SWIGTYPE_p_CvTypeInfo swig_types[97]
#define SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t swig_types[98]
#define SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t swig_types[99]
#define SWIGTYPE_p_CvTypedSeqT_CvPoint_t swig_types[100]
#define SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t swig_types[101]
#define SWIGTYPE_p_CvTypedSeqT_CvRect_t swig_types[102]
#define SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t swig_types[103]
#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t swig_types[104]
#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t swig_types[105]
#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t swig_types[106]
#define SWIGTYPE_p__CvContourScanner swig_types[107]
#define SWIGTYPE_p__IplConvKernel swig_types[108]
#define SWIGTYPE_p__IplConvKernelFP swig_types[109]
#define SWIGTYPE_p__IplImage swig_types[110]
#define SWIGTYPE_p__IplROI swig_types[111]
#define SWIGTYPE_p__IplTileInfo swig_types[112]
#define SWIGTYPE_p_a_2__float swig_types[113]
#define SWIGTYPE_p_a_2__signed_char swig_types[114]
#define SWIGTYPE_p_a_3__float swig_types[115]
#define SWIGTYPE_p_allocator_type swig_types[116]
#define SWIGTYPE_p_char swig_types[117]
#define SWIGTYPE_p_difference_type swig_types[118]
#define SWIGTYPE_p_double swig_types[119]
#define SWIGTYPE_p_f_int_int_int_int_int__p__IplROI swig_types[120]
#define SWIGTYPE_p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage swig_types[121]
#define SWIGTYPE_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int swig_types[122]
#define SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void swig_types[123]
#define SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void swig_types[124]
#define SWIGTYPE_p_f_p__IplImage_int__void swig_types[125]
#define SWIGTYPE_p_f_p__IplImage_int_int__void swig_types[126]
#define SWIGTYPE_p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void swig_types[127]
#define SWIGTYPE_p_f_p_p_void__void swig_types[128]
#define SWIGTYPE_p_f_p_q_const__IplImage__p__IplImage swig_types[129]
#define SWIGTYPE_p_f_p_q_const__char_int__p_CvMat swig_types[130]
#define SWIGTYPE_p_f_p_q_const__char_int__p__IplImage swig_types[131]
#define SWIGTYPE_p_f_p_q_const__char_p_q_const__void__int swig_types[132]
#define SWIGTYPE_p_f_p_q_const__char_p_q_const__void__void swig_types[133]
#define SWIGTYPE_p_f_p_q_const__float_p_q_const__float_p_void__float swig_types[134]
#define SWIGTYPE_p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void swig_types[135]
#define SWIGTYPE_p_f_p_q_const__void__int swig_types[136]
#define SWIGTYPE_p_f_p_q_const__void__p_void swig_types[137]
#define SWIGTYPE_p_f_p_q_const__void_p_q_const__void_p_void__int swig_types[138]
#define SWIGTYPE_p_f_p_void_p_void__int swig_types[139]
#define SWIGTYPE_p_f_size_t_p_void__p_void swig_types[140]
#define SWIGTYPE_p_float swig_types[141]
#define SWIGTYPE_p_int swig_types[142]
#define SWIGTYPE_p_long_long swig_types[143]
#define SWIGTYPE_p_p_CvGraphEdge swig_types[144]
#define SWIGTYPE_p_p_CvGraphVtx swig_types[145]
#define SWIGTYPE_p_p_CvHistogram swig_types[146]
#define SWIGTYPE_p_p_CvMat swig_types[147]
#define SWIGTYPE_p_p_CvMatND swig_types[148]
#define SWIGTYPE_p_p_CvPoint swig_types[149]
#define SWIGTYPE_p_p_CvSeq swig_types[150]
#define SWIGTYPE_p_p_CvSeqBlock swig_types[151]
#define SWIGTYPE_p_p_CvSetElem swig_types[152]
#define SWIGTYPE_p_p_CvStereoBMState swig_types[153]
#define SWIGTYPE_p_p_CvStereoGCState swig_types[154]
#define SWIGTYPE_p_p_CvSubdiv2DPoint swig_types[155]
#define SWIGTYPE_p_p_CvTypedSeqT_CvConnectedComp_t swig_types[156]
#define SWIGTYPE_p_p_CvTypedSeqT_CvPoint2D32f_t swig_types[157]
#define SWIGTYPE_p_p_CvTypedSeqT_CvPoint_t swig_types[158]
#define SWIGTYPE_p_p_CvTypedSeqT_CvQuadEdge2D_t swig_types[159]
#define SWIGTYPE_p_p_CvTypedSeqT_CvRect_t swig_types[160]
#define SWIGTYPE_p_p_CvTypedSeqT_CvSeq_p_t swig_types[161]
#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t swig_types[162]
#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_float_2_t_t swig_types[163]
#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_float_3_t_t swig_types[164]
#define SWIGTYPE_p_p_PyObject swig_types[165]
#define SWIGTYPE_p_p__CvContourScanner swig_types[166]
#define SWIGTYPE_p_p__IplImage swig_types[167]
#define SWIGTYPE_p_p_char swig_types[168]
#define SWIGTYPE_p_p_double swig_types[169]
#define SWIGTYPE_p_p_float swig_types[170]
#define SWIGTYPE_p_p_p_CvMat swig_types[171]
#define SWIGTYPE_p_p_unsigned_char swig_types[172]
#define SWIGTYPE_p_p_void swig_types[173]
#define SWIGTYPE_p_short swig_types[174]
#define SWIGTYPE_p_signed_char swig_types[175]
#define SWIGTYPE_p_size_t swig_types[176]
#define SWIGTYPE_p_size_type swig_types[177]
#define SWIGTYPE_p_std__invalid_argument swig_types[178]
#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t swig_types[179]
#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type swig_types[180]
#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type swig_types[181]
#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t swig_types[182]
#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type swig_types[183]
#define SWIGTYPE_p_swig__PySwigIterator swig_types[184]
#define SWIGTYPE_p_unsigned_char swig_types[185]
#define SWIGTYPE_p_unsigned_int swig_types[186]
#define SWIGTYPE_p_unsigned_long_long swig_types[187]
#define SWIGTYPE_p_unsigned_short swig_types[188]
#define SWIGTYPE_p_value_type swig_types[189]
#define SWIGTYPE_p_void swig_types[190]
static swig_type_info *swig_types[192];
static swig_module_info swig_module = {swig_types, 191, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
# error "This python version requires swig to be run with the '-classic' option"
# endif
#endif
/*-----------------------------------------------
@(target):= _cv.so
------------------------------------------------*/
#define SWIG_init init_cv
#define SWIG_name "_cv"
#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
#include <stdexcept>
namespace swig {
class PyObject_ptr {
protected:
PyObject *_obj;
public:
PyObject_ptr() :_obj(0)
{
}
PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
{
Py_XINCREF(_obj);
}
PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
{
if (initial_ref) {
Py_XINCREF(_obj);
}
}
PyObject_ptr & operator=(const PyObject_ptr& item)
{
Py_XINCREF(item._obj);
Py_XDECREF(_obj);
_obj = item._obj;
return *this;
}
~PyObject_ptr()
{
Py_XDECREF(_obj);
}
operator PyObject *() const
{
return _obj;
}
PyObject *operator->() const
{
return _obj;
}
};
}
namespace swig {
struct PyObject_var : PyObject_ptr {
PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
PyObject_var & operator = (PyObject* obj)
{
Py_XDECREF(_obj);
_obj = obj;
return *this;
}
};
}
#include "pyhelpers.h"
#include "pycvseq.hpp"
#include "error.h"
static CvArr * PyObject_to_CvArr(PyObject * obj, bool * freearg);
static CvArr * PySequence_to_CvArr( PyObject * obj );
// convert a python sequence/array/list object into a c-array
#define PyObject_AsArrayImpl(func, ctype, ptype) \
int func(PyObject * obj, ctype * array, int len){ \
void * mat_vptr=NULL; \
void * im_vptr=NULL; \
if(PyNumber_Check(obj)){ \
memset( array, 0, sizeof(ctype)*len ); \
array[0] = PyObject_As##ptype( obj ); \
} \
else if(PyList_Check(obj) || PyTuple_Check(obj)){ \
int seqsize = PySequence_Size(obj); \
for(int i=0; i<len && i<seqsize; i++){ \
if(i<seqsize){ \
array[i] = PyObject_As##ptype( PySequence_GetItem(obj, i) ); \
} \
else{ \
array[i] = 0; \
} \
} \
} \
else if( SWIG_ConvertPtr(obj, &mat_vptr, SWIGTYPE_p_CvMat, 0)!=-1 || \
SWIG_ConvertPtr(obj, &im_vptr, SWIGTYPE_p__IplImage, 0)!=-1) \
{ \
CvMat * mat = (CvMat *) mat_vptr; \
CvMat stub; \
if(im_vptr) mat = cvGetMat(im_vptr, &stub); \
if( mat->rows!=1 && mat->cols!=1 ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr must be row or column vector" ); \
return -1; \
} \
if( mat->rows==1 && mat->cols==1 ){ \
CvScalar val; \
if( len!=CV_MAT_CN(mat->type) ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr channels != length" ); \
return -1; \
} \
val = cvGet1D(mat, 0); \
for(int i=0; i<len; i++){ \
array[i] = (ctype) val.val[i]; \
} \
} \
else{ \
mat = cvReshape(mat, &stub, -1, mat->rows*mat->cols); \
if( mat->rows != len ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr rows or cols must equal length" ); \
return -1; \
} \
for(int i=0; i<len; i++){ \
CvScalar val = cvGet1D(mat, i); \
array[i] = (ctype) val.val[0]; \
} \
} \
} \
else{ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: Expected a number, sequence or CvArr" ); \
return -1; \
} \
return 0; \
}
PyObject_AsArrayImpl( PyObject_AsFloatArray, float, Double );
PyObject_AsArrayImpl( PyObject_AsDoubleArray, double, Double );
PyObject_AsArrayImpl( PyObject_AsLongArray, int, Long );
static CvPoint PyObject_to_CvPoint(PyObject * obj){
CvPoint val;
CvPoint *ptr;
CvPoint2D32f * ptr2D32f;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvPointFrom32f( *ptr2D32f );
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPointFrom32f(cvPoint2D32f( scalar->val[0], scalar->val[1] ));
}
if(PyObject_AsLongArray(obj, (int *) &val, 2) != -1){
return val;
}
PyErr_SetString( PyExc_TypeError, "could not convert to CvPoint");
return cvPoint(0,0);
}
static CvPoint2D32f PyObject_to_CvPoint2D32f(PyObject * obj){
CvPoint2D32f val;
CvPoint2D32f *ptr2D32f;
CvPoint *ptr;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return *ptr2D32f;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvPointTo32f(*ptr);
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPoint2D32f( scalar->val[0], scalar->val[1] );
}
if(PyObject_AsFloatArray(obj, (float *) &val, 2) != -1){
return val;
}
PyErr_SetString(PyExc_TypeError, "could not convert to CvPoint2D32f");
return cvPoint2D32f(0,0);
}
/* Check if this object can be interpreted as a CvScalar */
static bool CvScalar_Check(PyObject * obj){
void * vptr;
CvScalar val;
return SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1 ||
SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0 ) != -1 ||
SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0 ) != -1 ||
PyObject_AsDoubleArray(obj, val.val, 4) !=-1;
}
static CvScalar PyObject_to_CvScalar(PyObject * obj){
CvScalar val;
CvScalar * ptr;
CvPoint2D32f *ptr2D32f;
CvPoint *pt_ptr;
void * vptr;
if( SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1)
{
ptr = (CvScalar *) vptr;
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvScalar(ptr2D32f->x, ptr2D32f->y);
}
if( SWIG_ConvertPtr(obj, (void**)&pt_ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvScalar(pt_ptr->x, pt_ptr->y);
}
if(PyObject_AsDoubleArray(obj, val.val, 4)!=-1){
return val;
}
return cvScalar(-1,-1,-1,-1);
}
/* if python sequence type, convert to CvMat or CvMatND */
static CvArr * PyObject_to_CvArr(PyObject * obj, bool * freearg){
CvArr * cvarr;
*freearg = false;
// check if OpenCV type
if( PySwigObject_Check(obj) ){
SWIG_ConvertPtr(obj, &cvarr, 0, SWIG_POINTER_EXCEPTION);
}
else if(PyList_Check(obj) || PyTuple_Check(obj)){
cvarr = PySequence_to_CvArr( obj );
*freearg = (cvarr != NULL);
}
else if(PyLong_Check(obj) && PyLong_AsLong(obj)==0){
return NULL;
}
else {
SWIG_ConvertPtr(obj, (void**)&cvarr, 0, SWIG_POINTER_EXCEPTION);
}
return cvarr;
}
static int PyObject_GetElemType(PyObject * obj){
void *vptr;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvRect, 0) != -1) return CV_32SC4;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D32f, 0) != -1) return CV_32FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D64f, 0) != -1) return CV_64FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D64f, 0) != -1) return CV_64FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0) != -1) return CV_64FC4;
if(PyTuple_Check(obj) || PyList_Check(obj)) return CV_MAKE_TYPE(CV_32F, PySequence_Size( obj ));
if(PyLong_Check(obj)) return CV_32S;
return CV_32F;
}
// Would like this to convert Python lists to CvMat
// Also lists of CvPoints, CvScalars, CvMats? etc
static CvArr * PySequence_to_CvArr( PyObject * obj ){
int dims[CV_MAX_DIM] = {1,1,1};
int ndim=0;
int cvtype;
PyObject * item;
// figure out dimensions
for(item = obj;
(PyTuple_Check(item) || PyList_Check(item));
item = PySequence_GetItem(item, 0))
{
dims[ndim] = PySequence_Size( item );
ndim++;
}
if(ndim==0){
PyErr_SetString(PyExc_TypeError, "Cannot convert an empty python object to a CvArr");
return NULL;
}
cvtype = PyObject_GetElemType(item);
// collapse last dim into NCH if we found a single channel, but the last dim is <=3
if(CV_MAT_CN(cvtype)==1 && dims[ndim-1]>1 && dims[ndim-1]<4){
cvtype=CV_MAKE_TYPE(cvtype, dims[ndim-1]);
dims[ndim-1]=1;
ndim--;
}
if(cvtype==-1){
PyErr_SetString(PyExc_TypeError, "Could not determine OpenCV element type of Python sequence");
return NULL;
}
// CvMat
if(ndim<=2){
CvMat *m = cvCreateMat(dims[0], dims[1], cvtype);
for(int i=0; i<dims[0]; i++){
PyObject * rowobj = PySequence_GetItem(obj, i);
if( dims[1] > 1 ){
// double check size
assert((PyTuple_Check(rowobj) || PyList_Check(rowobj)) &&
PySequence_Size(rowobj) == dims[1]);
for(int j=0; j<dims[1]; j++){
PyObject * colobj = PySequence_GetItem(rowobj, j);
cvSet2D( m, i, j, PyObject_to_CvScalar( colobj ) );
}
}
else{
cvSet1D(m, i, PyObject_to_CvScalar( rowobj ) );
}
}
return (CvArr *) m;
}
// CvMatND
PyErr_SetString(PyExc_TypeError, "Cannot convert Python Object to CvArr -- ndim > 3");
return NULL;
}
// Wrapper class
class CvRNG_Wrapper {
private:
CvRNG m_val;
public:
CvRNG_Wrapper( const CvRNG & val ) :
m_val(val)
{
}
CvRNG * ptr() { return &m_val; }
CvRNG & ref() { return m_val; }
bool operator==(const CvRNG_Wrapper & x){
return m_val==x.m_val;
}
bool operator!=(const CvRNG_Wrapper & x){
return m_val!=x.m_val;
}
};
SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
int res = SWIG_TypeError;
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
} else if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
double d = PyFloat_AsDouble(obj);
if (!PyErr_Occurred()) {
if (val) *val = d;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
} else {
PyErr_Clear();
}
}
}
#endif
return res;
}
#include <float.h>
#include <math.h>
SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
double x = *d;
if ((min <= x && x <= max)) {
double fx = floor(x);
double cx = ceil(x);
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
if ((errno == EDOM) || (errno == ERANGE)) {
errno = 0;
} else {
double summ, reps, diff;
if (rd < x) {
diff = x - rd;
} else if (rd > x) {
diff = rd - x;
} else {
return 1;
}
summ = rd + x;
reps = diff/summ;
if (reps < 8*DBL_EPSILON) {
*d = rd;
return 1;
}
}
}
return 0;
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
{
if (PyInt_Check(obj)) {
long v = PyInt_AsLong(obj);
if (v >= 0) {
if (val) *val = v;
return SWIG_OK;
} else {
return SWIG_OverflowError;
}
} else if (PyLong_Check(obj)) {
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
unsigned long v = PyLong_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
if (val) *val = (unsigned long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
# define LLONG_MAX __LONG_LONG_MAX__
# define LLONG_MIN (-LLONG_MAX - 1LL)
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, uint64 *val)
{
int res = SWIG_TypeError;
if (PyLong_Check(obj)) {
uint64 v = PyLong_AsUnsignedLongLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
} else {
unsigned long v;
res = SWIG_AsVal_unsigned_SS_long (obj,&v);
if (SWIG_IsOK(res)) {
if (val) *val = v;
return res;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
const double mant_max = 1LL << DBL_MANT_DIG;
double d;
res = SWIG_AsVal_double (obj,&d);
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
if (val) *val = (uint64)(d);
return SWIG_AddCast(res);
}
res = SWIG_TypeError;
}
#endif
return res;
}
SWIGINTERNINLINE PyObject*
SWIG_From_bool (bool value)
{
return PyBool_FromLong(value ? 1 : 0);
}
// Wrapper class
class CvSubdiv2DEdge_Wrapper {
private:
CvSubdiv2DEdge m_val;
public:
CvSubdiv2DEdge_Wrapper( const CvSubdiv2DEdge & val ) :
m_val(val)
{
}
CvSubdiv2DEdge * ptr() { return &m_val; }
CvSubdiv2DEdge & ref() { return m_val; }
bool operator==(const CvSubdiv2DEdge_Wrapper & x){
return m_val==x.m_val;
}
bool operator!=(const CvSubdiv2DEdge_Wrapper & x){
return m_val!=x.m_val;
}
};
SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
unsigned long v;
int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
return res;
}
#include "cvshadow.h"
#include <stdexcept>
#if defined(__GNUC__)
# if __GNUC__ == 2 && __GNUC_MINOR <= 96
# define SWIG_STD_NOMODERN_STL
# endif
#endif
#include <string>
#include <stdexcept>
#include <string>
#include <iostream>
namespace swig {
struct stop_iteration {
};
struct PySwigIterator {
private:
PyObject_ptr _seq;
protected:
PySwigIterator(PyObject *seq) : _seq(seq)
{
}
public:
virtual ~PySwigIterator() {}
// Access iterator method, required by Python
virtual PyObject *value() const = 0;
// Forward iterator method, required by Python
virtual PySwigIterator *incr(size_t n = 1) = 0;
// Backward iterator method, very common in C++, but not required in Python
virtual PySwigIterator *decr(size_t /*n*/ = 1)
{
throw stop_iteration();
}
// Random access iterator methods, but not required in Python
virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
virtual bool equal (const PySwigIterator &/*x*/) const
{
throw std::invalid_argument("operation not supported");
}
// C++ common/needed methods
virtual PySwigIterator *copy() const = 0;
PyObject *next()
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
PyObject *obj = value();
incr();
SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
return obj;
}
PyObject *previous()
{
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
decr();
PyObject *obj = value();
SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
return obj;
}
PySwigIterator *advance(ptrdiff_t n)
{
return (n > 0) ? incr(n) : decr(-n);
}
bool operator == (const PySwigIterator& x) const
{
return equal(x);
}
bool operator != (const PySwigIterator& x) const
{
return ! operator==(x);
}
PySwigIterator& operator += (ptrdiff_t n)
{
return *advance(n);
}
PySwigIterator& operator -= (ptrdiff_t n)
{
return *advance(-n);
}
PySwigIterator* operator + (ptrdiff_t n) const
{
return copy()->advance(n);
}
PySwigIterator* operator - (ptrdiff_t n) const
{
return copy()->advance(-n);
}
ptrdiff_t operator - (const PySwigIterator& x) const
{
return x.distance(*this);
}
static swig_type_info* descriptor() {
static int init = 0;
static swig_type_info* desc = 0;
if (!init) {
desc = SWIG_TypeQuery("swig::PySwigIterator *");
init = 1;
}
return desc;
}
};
}
#define SWIG_From_long PyInt_FromLong
SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t (ptrdiff_t value)
{
return SWIG_From_long (static_cast< long >(value));
}
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
} else if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
int dispatch = 0;
long v = PyInt_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_AddCast(SWIG_OK);
} else {
PyErr_Clear();
}
if (!dispatch) {
double d;
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
if (val) *val = (long)(d);
return res;
}
}
}
#endif
return SWIG_TypeError;
}
SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
long v;
int res = SWIG_AsVal_long (obj, val ? &v : 0);
if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
return res;
}
#include <stdexcept>
#include <algorithm>
#include <vector>
#include <utility>
#include <map>
#include <algorithm>
#include <stdexcept>
namespace swig {
template <class Type>
struct noconst_traits {
typedef Type noconst_type;
};
template <class Type>
struct noconst_traits<const Type> {
typedef Type noconst_type;
};
/*
type categories
*/
struct pointer_category { };
struct value_category { };
/*
General traits that provides type_name and type_info
*/
template <class Type> struct traits { };
template <class Type>
inline const char* type_name() {
return traits<typename noconst_traits<Type >::noconst_type >::type_name();
}
template <class Type>
struct traits_info {
static swig_type_info *type_query(std::string name) {
name += " *";
return SWIG_TypeQuery(name.c_str());
}
static swig_type_info *type_info() {
static swig_type_info *info = type_query(type_name<Type>());
return info;
}
};
template <class Type>
inline swig_type_info *type_info() {
return traits_info<Type>::type_info();
}
/*
Partial specialization for pointers
*/
template <class Type> struct traits <Type *> {
typedef pointer_category category;
static std::string make_ptr_name(const char* name) {
std::string ptrname = name;
ptrname += " *";
return ptrname;
}
static const char* type_name() {
static std::string name = make_ptr_name(swig::type_name<Type>());
return name.c_str();
}
};
template <class Type, class Category>
struct traits_as { };
template <class Type, class Category>
struct traits_check { };
}
namespace swig {
/*
Traits that provides the from method
*/
template <class Type> struct traits_from_ptr {
static PyObject *from(Type *val, int owner = 0) {
return SWIG_NewPointerObj(val, type_info<Type>(), owner);
}
};
template <class Type> struct traits_from {
static PyObject *from(const Type& val) {
return traits_from_ptr<Type>::from(new Type(val), 1);
}
};
template <class Type> struct traits_from<Type *> {
static PyObject *from(Type* val) {
return traits_from_ptr<Type>::from(val, 0);
}
};
template <class Type> struct traits_from<const Type *> {
static PyObject *from(const Type* val) {
return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
}
};
template <class Type>
inline PyObject *from(const Type& val) {
return traits_from<Type>::from(val);
}
template <class Type>
inline PyObject *from_ptr(Type* val, int owner) {
return traits_from_ptr<Type>::from(val, owner);
}
/*
Traits that provides the asval/as/check method
*/
template <class Type>
struct traits_asptr {
static int asptr(PyObject *obj, Type **val) {
Type *p;
int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
if (SWIG_IsOK(res)) {
if (val) *val = p;
}
return res;
}
};
template <class Type>
inline int asptr(PyObject *obj, Type **vptr) {
return traits_asptr<Type>::asptr(obj, vptr);
}
template <class Type>
struct traits_asval {
static int asval(PyObject *obj, Type *val) {
if (val) {
Type *p = 0;
int res = traits_asptr<Type>::asptr(obj, &p);
if (!SWIG_IsOK(res)) return res;
if (p) {
typedef typename noconst_traits<Type>::noconst_type noconst_type;
*(const_cast<noconst_type*>(val)) = *p;
if (SWIG_IsNewObj(res)){
delete p;
res = SWIG_DelNewMask(res);
}
return res;
} else {
return SWIG_ERROR;
}
} else {
return traits_asptr<Type>::asptr(obj, (Type **)(0));
}
}
};
template <class Type> struct traits_asval<Type*> {
static int asval(PyObject *obj, Type **val) {
if (val) {
typedef typename noconst_traits<Type>::noconst_type noconst_type;
noconst_type *p = 0;
int res = traits_asptr<noconst_type>::asptr(obj, &p);
if (SWIG_IsOK(res)) {
*(const_cast<noconst_type**>(val)) = p;
}
return res;
} else {
return traits_asptr<Type>::asptr(obj, (Type **)(0));
}
}
};
template <class Type>
inline int asval(PyObject *obj, Type *val) {
return traits_asval<Type>::asval(obj, val);
}
template <class Type>
struct traits_as<Type, value_category> {
static Type as(PyObject *obj, bool throw_error) {
Type v;
int res = asval(obj, &v);
if (!obj || !SWIG_IsOK(res)) {
if (!PyErr_Occurred()) {
::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
}
if (throw_error) throw std::invalid_argument("bad type");
}
return v;
}
};
template <class Type>
struct traits_as<Type, pointer_category> {
static Type as(PyObject *obj, bool throw_error) {
Type *v = 0;
int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
if (SWIG_IsOK(res) && v) {
if (SWIG_IsNewObj(res)) {
Type r(*v);
delete v;
return r;
} else {
return *v;
}
} else {
// Uninitialized return value, no Type() constructor required.
static Type *v_def = (Type*) malloc(sizeof(Type));
if (!PyErr_Occurred()) {
SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
}
if (throw_error) throw std::invalid_argument("bad type");
memset(v_def,0,sizeof(Type));
return *v_def;
}
}
};
template <class Type>
struct traits_as<Type*, pointer_category> {
static Type* as(PyObject *obj, bool throw_error) {
Type *v = 0;
int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
if (SWIG_IsOK(res)) {
return v;
} else {
if (!PyErr_Occurred()) {
SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
}
if (throw_error) throw std::invalid_argument("bad type");
return 0;
}
}
};
template <class Type>
inline Type as(PyObject *obj, bool te = false) {
return traits_as<Type, typename traits<Type>::category>::as(obj, te);
}
template <class Type>
struct traits_check<Type, value_category> {
static bool check(PyObject *obj) {
int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
return SWIG_IsOK(res) ? true : false;
}
};
template <class Type>
struct traits_check<Type, pointer_category> {
static bool check(PyObject *obj) {
int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
return SWIG_IsOK(res) ? true : false;
}
};
template <class Type>
inline bool check(PyObject *obj) {
return traits_check<Type, typename traits<Type>::category>::check(obj);
}
}
#include <functional>
namespace std {
template <>
struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
{
bool
operator()(PyObject * v, PyObject *w) const
{
bool res;
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
res = PyObject_Compare(v, w) < 0;
SWIG_PYTHON_THREAD_END_BLOCK;
return res;
}
};
template <>
struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
{
bool
operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
{
return std::less<PyObject *>()(v, w);
}
};
template <>
struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
{
bool
operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
{
return std::less<PyObject *>()(v, w);
}
};
}
namespace swig {
template <> struct traits<PyObject *> {
typedef value_category category;
static const char* type_name() { return "PyObject *"; }
};
template <> struct traits_asval<PyObject * > {
typedef PyObject * value_type;
static int asval(PyObject *obj, value_type *val) {
if (val) *val = obj;
return SWIG_OK;
}
};
template <>
struct traits_check<PyObject *, value_category> {
static bool check(PyObject *) {
return true;
}
};
template <> struct traits_from<PyObject *> {
typedef PyObject * value_type;
static PyObject *from(const value_type& val) {
Py_XINCREF(val);
return val;
}
};
}
namespace swig {
inline size_t
check_index(ptrdiff_t i, size_t size, bool insert = false) {
if ( i < 0 ) {
if ((size_t) (-i) <= size)
return (size_t) (i + size);
} else if ( (size_t) i < size ) {
return (size_t) i;
} else if (insert && ((size_t) i == size)) {
return size;
}
throw std::out_of_range("index out of range");
}
inline size_t
slice_index(ptrdiff_t i, size_t size) {
if ( i < 0 ) {
if ((size_t) (-i) <= size) {
return (size_t) (i + size);
} else {
throw std::out_of_range("index out of range");
}
} else {
return ( (size_t) i < size ) ? ((size_t) i) : size;
}
}
template <class Sequence, class Difference>
inline typename Sequence::iterator
getpos(Sequence* self, Difference i) {
typename Sequence::iterator pos = self->begin();
std::advance(pos, check_index(i,self->size()));
return pos;
}
template <class Sequence, class Difference>
inline typename Sequence::const_iterator
cgetpos(const Sequence* self, Difference i) {
typename Sequence::const_iterator pos = self->begin();
std::advance(pos, check_index(i,self->size()));
return pos;
}
template <class Sequence, class Difference>
inline Sequence*
getslice(const Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj > ii) {
typename Sequence::const_iterator vb = self->begin();
typename Sequence::const_iterator ve = self->begin();
std::advance(vb,ii);
std::advance(ve,jj);
return new Sequence(vb, ve);
} else {
return new Sequence();
}
}
template <class Sequence, class Difference, class InputSeq>
inline void
setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj < ii) jj = ii;
size_t ssize = jj - ii;
if (ssize <= v.size()) {
typename Sequence::iterator sb = self->begin();
typename InputSeq::const_iterator vmid = v.begin();
std::advance(sb,ii);
std::advance(vmid, jj - ii);
self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
} else {
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
self->erase(sb,se);
self->insert(sb, v.begin(), v.end());
}
}
template <class Sequence, class Difference>
inline void
delslice(Sequence* self, Difference i, Difference j) {
typename Sequence::size_type size = self->size();
typename Sequence::size_type ii = swig::check_index(i, size, true);
typename Sequence::size_type jj = swig::slice_index(j, size);
if (jj > ii) {
typename Sequence::iterator sb = self->begin();
typename Sequence::iterator se = self->begin();
std::advance(sb,ii);
std::advance(se,jj);
self->erase(sb,se);
}
}
}
#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
# define SWIG_STD_NOITERATOR_TRAITS_STL
# endif
#endif
#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
template <class Iterator>
struct iterator_traits {
typedef ptrdiff_t difference_type;
typedef typename Iterator::value_type value_type;
};
template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
typedef Distance difference_type;
typedef T value_type;
};
template <class T>
struct iterator_traits<T*> {
typedef T value_type;
typedef ptrdiff_t difference_type;
};
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first; ++__n;
}
return __n;
}
}
#endif
namespace swig {
template<typename OutIterator>
class PySwigIterator_T : public PySwigIterator
{
public:
typedef OutIterator out_iterator;
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
typedef PySwigIterator_T<out_iterator> self_type;
PySwigIterator_T(out_iterator curr, PyObject *seq)
: PySwigIterator(seq), current(curr)
{
}
const out_iterator& get_current() const
{
return current;
}
bool equal (const PySwigIterator &iter) const
{
const self_type *iters = dynamic_cast<const self_type *>(&iter);
if (iters) {
return (current == iters->get_current());
} else {
throw std::invalid_argument("bad iterator type");
}
}
ptrdiff_t distance(const PySwigIterator &iter) const
{
const self_type *iters = dynamic_cast<const self_type *>(&iter);
if (iters) {
return std::distance(current, iters->get_current());
} else {
throw std::invalid_argument("bad iterator type");
}
}
protected:
out_iterator current;
};
template <class ValueType>
struct from_oper
{
typedef const ValueType& argument_type;
typedef PyObject *result_type;
result_type operator()(argument_type v) const
{
return swig::from(v);
}
};
template<typename OutIterator,
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
typename FromOper = from_oper<ValueType> >
class PySwigIteratorOpen_T : public PySwigIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
typedef PySwigIterator_T<out_iterator> base;
typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
: PySwigIterator_T<OutIterator>(curr, seq)
{
}
PyObject *value() const {
return from(static_cast<const value_type&>(*(base::current)));
}
PySwigIterator *copy() const
{
return new self_type(*this);
}
PySwigIterator *incr(size_t n = 1)
{
while (n--) {
++base::current;
}
return this;
}
PySwigIterator *decr(size_t n = 1)
{
while (n--) {
--base::current;
}
return this;
}
};
template<typename OutIterator,
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
typename FromOper = from_oper<ValueType> >
class PySwigIteratorClosed_T : public PySwigIterator_T<OutIterator>
{
public:
FromOper from;
typedef OutIterator out_iterator;
typedef ValueType value_type;
typedef PySwigIterator_T<out_iterator> base;
typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
: PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
{
}
PyObject *value() const {
if (base::current == end) {
throw stop_iteration();
} else {
return from(static_cast<const value_type&>(*(base::current)));
}
}
PySwigIterator *copy() const
{
return new self_type(*this);
}
PySwigIterator *incr(size_t n = 1)
{
while (n--) {
if (base::current == end) {
throw stop_iteration();
} else {
++base::current;
}
}
return this;
}
PySwigIterator *decr(size_t n = 1)
{
while (n--) {
if (base::current == begin) {
throw stop_iteration();
} else {
--base::current;
}
}
return this;
}
private:
out_iterator begin;
out_iterator end;
};
template<typename OutIter>
inline PySwigIterator*
make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
{
return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
}
template<typename OutIter>
inline PySwigIterator*
make_output_iterator(const OutIter& current, PyObject *seq = 0)
{
return new PySwigIteratorOpen_T<OutIter>(current, seq);
}
}
namespace swig
{
template <class T>
struct PySequence_Ref
{
PySequence_Ref(PyObject* seq, int index)
: _seq(seq), _index(index)
{
}
operator T () const
{
swig::PyObject_var item = PySequence_GetItem(_seq, _index);
try {
return swig::as<T>(item, true);
} catch (std::exception& e) {
char msg[1024];
sprintf(msg, "in sequence element %d ", _index);
if (!PyErr_Occurred()) {
::SWIG_Error(SWIG_TypeError, swig::type_name<T>());
}
SWIG_Python_AddErrorMsg(msg);
SWIG_Python_AddErrorMsg(e.what());
throw;
}
}
PySequence_Ref& operator=(const T& v)
{
PySequence_SetItem(_seq, _index, swig::from<T>(v));
return *this;
}
private:
PyObject* _seq;
int _index;
};
template <class T>
struct PySequence_ArrowProxy
{
PySequence_ArrowProxy(const T& x): m_value(x) {}
const T* operator->() const { return &m_value; }
operator const T*() const { return &m_value; }
T m_value;
};
template <class T, class Reference >
struct PySequence_InputIterator
{
typedef PySequence_InputIterator<T, Reference > self;
typedef std::random_access_iterator_tag iterator_category;
typedef Reference reference;
typedef T value_type;
typedef T* pointer;
typedef int difference_type;
PySequence_InputIterator()
{
}
PySequence_InputIterator(PyObject* seq, int index)
: _seq(seq), _index(index)
{
}
reference operator*() const
{
return reference(_seq, _index);
}
PySequence_ArrowProxy<T>
operator->() const {
return PySequence_ArrowProxy<T>(operator*());
}
bool operator==(const self& ri) const
{
return (_index == ri._index) && (_seq == ri._seq);
}
bool operator!=(const self& ri) const
{
return !(operator==(ri));
}
self& operator ++ ()
{
++_index;
return *this;
}
self& operator -- ()
{
--_index;
return *this;
}
self& operator += (difference_type n)
{
_index += n;
return *this;
}
self operator +(difference_type n) const
{
return self(_seq, _index + n);
}
self& operator -= (difference_type n)
{
_index -= n;
return *this;
}
self operator -(difference_type n) const
{
return self(_seq, _index - n);
}
difference_type operator - (const self& ri) const
{
return _index - ri._index;
}
bool operator < (const self& ri) const
{
return _index < ri._index;
}
reference
operator[](difference_type n) const
{
return reference(_seq, _index + n);
}
private:
PyObject* _seq;
difference_type _index;
};
template <class T>
struct PySequence_Cont
{
typedef PySequence_Ref<T> reference;
typedef const PySequence_Ref<T> const_reference;
typedef T value_type;
typedef T* pointer;
typedef int difference_type;
typedef int size_type;
typedef const pointer const_pointer;
typedef PySequence_InputIterator<T, reference> iterator;
typedef PySequence_InputIterator<T, const_reference> const_iterator;
PySequence_Cont(PyObject* seq) : _seq(0)
{
if (!PySequence_Check(seq)) {
throw std::invalid_argument("a sequence is expected");
}
_seq = seq;
Py_INCREF(_seq);
}
~PySequence_Cont()
{
Py_XDECREF(_seq);
}
size_type size() const
{
return static_cast<size_type>(PySequence_Size(_seq));
}
bool empty() const
{
return size() == 0;
}
iterator begin()
{
return iterator(_seq, 0);
}
const_iterator begin() const
{
return const_iterator(_seq, 0);
}
iterator end()
{
return iterator(_seq, size());
}
const_iterator end() const
{
return const_iterator(_seq, size());
}
reference operator[](difference_type n)
{
return reference(_seq, n);
}
const_reference operator[](difference_type n) const
{
return const_reference(_seq, n);
}
bool check(bool set_err = true) const
{
int s = size();
for (int i = 0; i < s; ++i) {
swig::PyObject_var item = PySequence_GetItem(_seq, i);
if (!swig::check<value_type>(item)) {
if (set_err) {
char msg[1024];
sprintf(msg, "in sequence element %d", i);
SWIG_Error(SWIG_RuntimeError, msg);
}
return false;
}
}
return true;
}
private:
PyObject* _seq;
};
}
SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
double v;
int res = SWIG_AsVal_double (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < -FLT_MAX || v > FLT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< float >(v);
}
}
return res;
}
#define SWIG_From_double PyFloat_FromDouble
SWIGINTERNINLINE PyObject *
SWIG_From_float (float value)
{
return SWIG_From_double (value);
}
namespace swig {
template <> struct traits<float > {
typedef value_category category;
static const char* type_name() { return"float"; }
};
template <> struct traits_asval<float > {
typedef float value_type;
static int asval(PyObject *obj, value_type *val) {
return SWIG_AsVal_float (obj, val);
}
};
template <> struct traits_from<float > {
typedef float value_type;
static PyObject *from(const value_type& val) {
return SWIG_From_float (val);
}
};
}
namespace swig {
template <class PySeq, class Seq>
inline void
assign(const PySeq& pyseq, Seq* seq) {
// seq->assign(pyseq.begin(), pyseq.end()); // not used as not always implemented
typedef typename PySeq::value_type value_type;
typename PySeq::const_iterator it = pyseq.begin();
for (;it != pyseq.end(); ++it) {
seq->insert(seq->end(),(value_type)(*it));
}
}
template <class Seq, class T = typename Seq::value_type >
struct traits_asptr_stdseq {
typedef Seq sequence;
typedef T value_type;
static int asptr(PyObject *obj, sequence **seq) {
if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
sequence *p;
if (::SWIG_ConvertPtr(obj,(void**)&p,
swig::type_info<sequence>(),0) == SWIG_OK) {
if (seq) *seq = p;
return SWIG_OLDOBJ;
}
} else if (PySequence_Check(obj)) {
try {
PySequence_Cont<value_type> pyseq(obj);
if (seq) {
sequence *pseq = new sequence();
assign(pyseq, pseq);
*seq = pseq;
return SWIG_NEWOBJ;
} else {
return pyseq.check() ? SWIG_OK : SWIG_ERROR;
}
} catch (std::exception& e) {
if (seq) {
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, e.what());
}
}
return SWIG_ERROR;
}
}
return SWIG_ERROR;
}
};
template <class Seq, class T = typename Seq::value_type >
struct traits_from_stdseq {
typedef Seq sequence;
typedef T value_type;
typedef typename Seq::size_type size_type;
typedef typename sequence::const_iterator const_iterator;
static PyObject *from(const sequence& seq) {
#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
swig_type_info *desc = swig::type_info<sequence>();
if (desc && desc->clientdata) {
return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
}
#endif
size_type size = seq.size();
if (size <= (size_type)INT_MAX) {
PyObject *obj = PyTuple_New((int)size);
int i = 0;
for (const_iterator it = seq.begin();
it != seq.end(); ++it, ++i) {
PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
}
return obj;
} else {
PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
return NULL;
}
}
};
}
namespace swig {
template <class T>
struct traits_asptr<std::vector<T> > {
static int asptr(PyObject *obj, std::vector<T> **vec) {
return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
}
};
template <class T>
struct traits_from<std::vector<T> > {
static PyObject *from(const std::vector<T>& vec) {
return traits_from_stdseq<std::vector<T> >::from(vec);
}
};
}
namespace swig {
template <> struct traits<std::vector<float, std::allocator< float > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "float" "," "std::allocator< float >" " >";
}
};
}
SWIGINTERN swig::PySwigIterator *std_vector_Sl_float_Sg__iterator(std::vector< float > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_float_Sg____nonzero__(std::vector< float > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< float >::size_type std_vector_Sl_float_Sg____len__(std::vector< float > const *self){
return self->size();
}
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long (unsigned long value)
{
return (value > LONG_MAX) ?
PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}
SWIGINTERNINLINE PyObject *
SWIG_From_size_t (size_t value)
{
return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
}
SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg__pop(std::vector< float > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector<float,std::allocator< float > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN std::vector< float,std::allocator< float > > *std_vector_Sl_float_Sg____getslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j){
return swig::getslice(self, i, j);
}
SWIGINTERN void std_vector_Sl_float_Sg____setslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j,std::vector< float,std::allocator< float > > const &v){
swig::setslice(self, i, j, v);
}
SWIGINTERN void std_vector_Sl_float_Sg____delslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j){
swig::delslice(self, i, j);
}
SWIGINTERN void std_vector_Sl_float_Sg____delitem__(std::vector< float > *self,std::vector< float >::difference_type i){
self->erase(swig::getpos(self,i));
}
SWIGINTERN std::vector< float >::value_type const &std_vector_Sl_float_Sg____getitem__(std::vector< float > const *self,std::vector< float >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_float_Sg____setitem__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN void std_vector_Sl_float_Sg__append(std::vector< float > *self,std::vector< float >::value_type const &x){
self->push_back(x);
}
namespace swig {
template <> struct traits<CvPoint > {
typedef pointer_category category;
static const char* type_name() { return"CvPoint"; }
};
}
namespace swig {
template <> struct traits<std::vector<CvPoint, std::allocator< CvPoint > > > {
typedef pointer_category category;
static const char* type_name() {
return "std::vector<" "CvPoint" "," "std::allocator< CvPoint >" " >";
}
};
}
SWIGINTERN swig::PySwigIterator *std_vector_Sl_CvPoint_Sg__iterator(std::vector< CvPoint > *self,PyObject **PYTHON_SELF){
return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
}
SWIGINTERN bool std_vector_Sl_CvPoint_Sg____nonzero__(std::vector< CvPoint > const *self){
return !(self->empty());
}
SWIGINTERN std::vector< CvPoint >::size_type std_vector_Sl_CvPoint_Sg____len__(std::vector< CvPoint > const *self){
return self->size();
}
SWIGINTERN std::vector< CvPoint >::value_type std_vector_Sl_CvPoint_Sg__pop(std::vector< CvPoint > *self){
if (self->size() == 0)
throw std::out_of_range("pop from empty container");
std::vector<CvPoint,std::allocator< CvPoint > >::value_type x = self->back();
self->pop_back();
return x;
}
SWIGINTERN std::vector< CvPoint,std::allocator< CvPoint > > *std_vector_Sl_CvPoint_Sg____getslice__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i,std::vector< CvPoint >::difference_type j){
return swig::getslice(self, i, j);
}
SWIGINTERN void std_vector_Sl_CvPoint_Sg____setslice__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i,std::vector< CvPoint >::difference_type j,std::vector< CvPoint,std::allocator< CvPoint > > const &v){
swig::setslice(self, i, j, v);
}
SWIGINTERN void std_vector_Sl_CvPoint_Sg____delslice__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i,std::vector< CvPoint >::difference_type j){
swig::delslice(self, i, j);
}
SWIGINTERN void std_vector_Sl_CvPoint_Sg____delitem__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i){
self->erase(swig::getpos(self,i));
}
SWIGINTERN std::vector< CvPoint >::value_type const &std_vector_Sl_CvPoint_Sg____getitem__(std::vector< CvPoint > const *self,std::vector< CvPoint >::difference_type i){
return *(swig::cgetpos(self, i));
}
SWIGINTERN void std_vector_Sl_CvPoint_Sg____setitem__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i,std::vector< CvPoint >::value_type const &x){
*(swig::getpos(self,i)) = x;
}
SWIGINTERN void std_vector_Sl_CvPoint_Sg__append(std::vector< CvPoint > *self,std::vector< CvPoint >::value_type const &x){
self->push_back(x);
}
SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
long v;
int res = SWIG_AsVal_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v < INT_MIN || v > INT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< int >(v);
}
}
return res;
}
void cvReleaseImage_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseMat_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseStructuringElement_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseConDensation_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseKalman_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseHist_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseHaarClassifierCascade_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleasePOSITObject_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseImageHeader_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseMatND_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseSparseMat_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseMemStorage_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseGraphScanner_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseFileStorage_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvRelease_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseCapture_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
void cvReleaseVideoWriter_Shadow(PyObject * obj){
Py_XDECREF(obj);
}
#include "cxtypes.h"
#include "cxcore.h"
#include "cvtypes.h"
#include "cv.h"
const signed char icvDepthToType[]=
{
-1, -1, CV_8U, CV_8S, CV_16U, CV_16S, -1, -1,
CV_32F, CV_32S, -1, -1, -1, -1, -1, -1, CV_64F, -1
};
CvModuleInfo* CvModule::first = 0;
CvModuleInfo* CvModule::last = 0;
CvTypeInfo* CvType::first = 0;
CvTypeInfo* CvType::last = 0;
#include "cv.h"
SWIGINTERNINLINE PyObject *
SWIG_From_int (int value)
{
return SWIG_From_long (value);
}
#include <stdlib.h>
extern const signed char icvDepthToType[];
#define icvIplToCvDepth( depth ) \
icvDepthToType[(((depth) & 255) >> 2) + ((depth) < 0)]
CvMat * cvCreateImageMat( CvSize size, int depth, int channels ){
depth = icvIplToCvDepth(depth);
return cvCreateMat( size.height, size.width, CV_MAKE_TYPE(depth, channels));
}
#define cvCloneImageMat( mat ) cvCloneMat( mat )
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
return PyString_FromStringAndSize(carray, static_cast< int >(size));
}
} else {
return SWIG_Py_Void();
}
}
SWIGINTERNINLINE PyObject *
SWIG_FromCharPtr(const char *cptr)
{
return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}
SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
unsigned long v;
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
if (SWIG_IsOK(res)) {
if ((v > UINT_MAX)) {
return SWIG_OverflowError;
} else {
if (val) *val = static_cast< unsigned int >(v);
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_int (unsigned int value)
{
return SWIG_From_unsigned_SS_long (value);
}
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, int64 *val)
{
int res = SWIG_TypeError;
if (PyLong_Check(obj)) {
int64 v = PyLong_AsLongLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
}
} else {
long v;
res = SWIG_AsVal_long (obj,&v);
if (SWIG_IsOK(res)) {
if (val) *val = v;
return res;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
{
const double mant_max = 1LL << DBL_MANT_DIG;
const double mant_min = -mant_max;
double d;
res = SWIG_AsVal_double (obj,&d);
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
if (val) *val = (int64)(d);
return SWIG_AddCast(res);
}
res = SWIG_TypeError;
}
#endif
return res;
}
SWIGINTERNINLINE PyObject*
SWIG_From_long_SS_long (int64 value)
{
return ((value < LONG_MIN) || (value > LONG_MAX)) ?
PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
SWIGINTERNINLINE PyObject*
SWIG_From_unsigned_SS_long_SS_long (uint64 value)
{
return (value > LONG_MAX) ?
PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
SWIGINTERN void delete_IplImage(IplImage *self){ IplImage * dummy = self; cvReleaseImage (& dummy); }
SWIGINTERN IplImage *IplImage_operator_SA___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAnd(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_SA__Se___SWIG_0(IplImage *self,CvArr *src){
cvAnd(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sa___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAdd(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sa__Se___SWIG_0(IplImage *self,CvArr *src){
cvAdd(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sm___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvMul(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sm__Se___SWIG_0(IplImage *self,CvArr *src){
cvMul(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Ss___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSub(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Ss__Se___SWIG_0(IplImage *self,CvArr *src){
cvSub(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sd___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvDiv(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sd__Se___SWIG_0(IplImage *self,CvArr *src){
cvDiv(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_So___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOr(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_So__Se___SWIG_0(IplImage *self,CvArr *src){
cvOr(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sx___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXor(self, src, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sx__Se___SWIG_0(IplImage *self,CvArr *src){
cvXor(self, src, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sa___SWIG_1(IplImage *self,CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAddS(self, val, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sa__Se___SWIG_1(IplImage *self,CvScalar val){
cvAddS(self, val, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sx___SWIG_1(IplImage *self,CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXorS(self, val, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sx__Se___SWIG_1(IplImage *self,CvScalar val){
cvXorS(self, val, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Ss___SWIG_1(IplImage *self,CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSubS(self, val, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Ss__Se___SWIG_1(IplImage *self,CvScalar val){
cvSubS(self, val, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_So___SWIG_1(IplImage *self,CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOrS(self, val, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_So__Se___SWIG_1(IplImage *self,CvScalar val){
cvOrS(self, val, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_SA___SWIG_1(IplImage *self,CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAndS(self, val, res);
return res;
}
SWIGINTERN IplImage *IplImage_operator_SA__Se___SWIG_1(IplImage *self,CvScalar val){
cvAndS(self, val, self);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sg__Se___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 2);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sg__Se___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 2);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Se__Se___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 0);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Se__Se___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 0);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sl__Se___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 4);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sl__Se___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 4);
return res;
}
SWIGINTERN IplImage *IplImage_operator_SN__Se___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 5);
return res;
}
SWIGINTERN IplImage *IplImage_operator_SN__Se___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 5);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sl___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 3);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sl___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 3);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sg___SWIG_0(IplImage *self,CvArr *src){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmp(self, src, res, 1);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sg___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, val, res, 1);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sm___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvConvertScale(self, res, val);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sm__Se___SWIG_1(IplImage *self,double val){
cvConvertScale(self, self, val);
return self;
}
SWIGINTERN IplImage *IplImage_operator_Sd___SWIG_1(IplImage *self,double val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvConvertScale(self, res, 1.0/val);
return res;
}
SWIGINTERN IplImage *IplImage_operator_Sd__Se___SWIG_1(IplImage *self,double val){
cvConvertScale(self, self, 1.0/val);
return self;
}
SWIGINTERN IplImage *IplImage___radd____SWIG_0(IplImage *self,CvArr *arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAdd(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rsub____SWIG_0(IplImage *self,CvArr *arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSub(arg, self, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rdiv__(IplImage *self,CvArr *arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvDiv(arg, self, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rmul____SWIG_0(IplImage *self,CvArr *arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvMul(arg, self, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___radd____SWIG_1(IplImage *self,CvScalar arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAddS(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___radd____SWIG_2(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAddS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rsub____SWIG_1(IplImage *self,CvScalar arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSubRS(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rsub____SWIG_2(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSubRS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rmul____SWIG_1(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvConvertScale(self, retarg, arg);
return retarg;
}
SWIGINTERN IplImage *IplImage___ror____SWIG_0(IplImage *self,CvScalar arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOrS(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___ror____SWIG_1(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOrS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rand____SWIG_0(IplImage *self,CvScalar arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAndS(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rand____SWIG_1(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAndS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rxor____SWIG_0(IplImage *self,CvScalar arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXorS(self, arg, retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___rxor____SWIG_1(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXorS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN IplImage *IplImage___req__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 0);
return retarg;
}
SWIGINTERN IplImage *IplImage___rgt__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 1);
return retarg;
}
SWIGINTERN IplImage *IplImage___rge__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 2);
return retarg;
}
SWIGINTERN IplImage *IplImage___rlt__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 3);
return retarg;
}
SWIGINTERN IplImage *IplImage___rle__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 4);
return retarg;
}
SWIGINTERN IplImage *IplImage___rne__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), 8, 1);
cvCmpS(self, arg, retarg, 5);
return retarg;
}
SWIGINTERN IplImage *IplImage___pow__(IplImage *self,double arg){
IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvPow(self, retarg, arg);
return retarg;
}
SWIGINTERN char *IplImage___str__(IplImage *self){
static char str[8];
cvArrPrint( self );
str[0]=0;
return str;
}
SWIGINTERN void IplImage___setitem____SWIG_0(IplImage *self,PyObject *object,double val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalarAll(val));
}
SWIGINTERN void IplImage___setitem____SWIG_1(IplImage *self,PyObject *object,CvPoint val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
SWIGINTERN void IplImage___setitem____SWIG_2(IplImage *self,PyObject *object,CvPoint2D32f val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
SWIGINTERN void IplImage___setitem____SWIG_3(IplImage *self,PyObject *object,CvScalar val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, val);
}
SWIGINTERN void IplImage___setitem____SWIG_4(IplImage *self,PyObject *object,CvArr *arr){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvConvert(arr, &tmp);
}
SWIGINTERN PyObject *IplImage___getitem__(IplImage *self,PyObject *object){
CvMat mat;
IplImage * im;
CvRect subrect = PySlice_to_CvRect( self, object );
// return scalar if single element
if(subrect.width==1 && subrect.height==1){
CvScalar * s;
int type = cvGetElemType( self );
if(CV_MAT_CN(type) > 1){
s = new CvScalar;
*s = cvGet2D( self, subrect.y, subrect.x );
return SWIG_NewPointerObj( s, SWIGTYPE_p_CvScalar, 1 );
}
switch(CV_MAT_DEPTH(type)){
case 0:
return PyLong_FromUnsignedLong( CV_IMAGE_ELEM(self, uchar, subrect.y, subrect.x ) );
case 1:
return PyLong_FromLong( CV_IMAGE_ELEM(self, char, subrect.y, subrect.x ) );
case 2:
return PyLong_FromUnsignedLong( CV_IMAGE_ELEM(self, ushort, subrect.y, subrect.x ) );
case 3:
return PyLong_FromLong( CV_IMAGE_ELEM(self, short, subrect.y, subrect.x ) );
case 4:
return PyLong_FromLong( CV_IMAGE_ELEM(self, int, subrect.y, subrect.x ) );
case 5:
return PyFloat_FromDouble( CV_IMAGE_ELEM(self, float, subrect.y, subrect.x) );
case 6:
return PyFloat_FromDouble( CV_IMAGE_ELEM(self, double, subrect.y, subrect.x) );
}
}
// otherwise return array
im = (IplImage *) cvAlloc(sizeof(IplImage));
cvGetSubRect(self, &mat, subrect);
im = cvGetImage(&mat, im);
return SWIG_NewPointerObj( im, SWIGTYPE_p__IplImage, 1 );
}
SWIGINTERN void delete_IplConvKernel(IplConvKernel *self){ IplConvKernel * dummy = self; cvReleaseStructuringElement (& dummy); }
typedef union {
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} CvMat_data;
SWIGINTERN void delete_CvMat(CvMat *self){ CvMat * dummy = self; cvReleaseMat (& dummy); }
SWIGINTERN CvMat *CvMat_operator_SA___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAnd(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_SA__Se___SWIG_0(CvMat *self,CvArr *src){
cvAnd(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sa___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAdd(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sa__Se___SWIG_0(CvMat *self,CvArr *src){
cvAdd(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sm___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvMul(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sm__Se___SWIG_0(CvMat *self,CvArr *src){
cvMul(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Ss___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvSub(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Ss__Se___SWIG_0(CvMat *self,CvArr *src){
cvSub(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sd___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvDiv(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sd__Se___SWIG_0(CvMat *self,CvArr *src){
cvDiv(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_So___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvOr(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_So__Se___SWIG_0(CvMat *self,CvArr *src){
cvOr(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sx___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvXor(self, src, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sx__Se___SWIG_0(CvMat *self,CvArr *src){
cvXor(self, src, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sa___SWIG_1(CvMat *self,CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAddS(self, val, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sa__Se___SWIG_1(CvMat *self,CvScalar val){
cvAddS(self, val, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sx___SWIG_1(CvMat *self,CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvXorS(self, val, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sx__Se___SWIG_1(CvMat *self,CvScalar val){
cvXorS(self, val, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Ss___SWIG_1(CvMat *self,CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvSubS(self, val, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Ss__Se___SWIG_1(CvMat *self,CvScalar val){
cvSubS(self, val, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_So___SWIG_1(CvMat *self,CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvOrS(self, val, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_So__Se___SWIG_1(CvMat *self,CvScalar val){
cvOrS(self, val, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_SA___SWIG_1(CvMat *self,CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAndS(self, val, res);
return res;
}
SWIGINTERN CvMat *CvMat_operator_SA__Se___SWIG_1(CvMat *self,CvScalar val){
cvAndS(self, val, self);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sg__Se___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 2);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sg__Se___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 2);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Se__Se___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 0);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Se__Se___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 0);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sl__Se___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 4);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sl__Se___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 4);
return res;
}
SWIGINTERN CvMat *CvMat_operator_SN__Se___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 5);
return res;
}
SWIGINTERN CvMat *CvMat_operator_SN__Se___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 5);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sl___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 3);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sl___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 3);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sg___SWIG_0(CvMat *self,CvArr *src){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmp(self, src, res, 1);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sg___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, val, res, 1);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sm___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvConvertScale(self, res, val);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sm__Se___SWIG_1(CvMat *self,double val){
cvConvertScale(self, self, val);
return self;
}
SWIGINTERN CvMat *CvMat_operator_Sd___SWIG_1(CvMat *self,double val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvConvertScale(self, res, 1.0/val);
return res;
}
SWIGINTERN CvMat *CvMat_operator_Sd__Se___SWIG_1(CvMat *self,double val){
cvConvertScale(self, self, 1.0/val);
return self;
}
SWIGINTERN CvMat *CvMat___radd____SWIG_0(CvMat *self,CvArr *arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvAdd(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rsub____SWIG_0(CvMat *self,CvArr *arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvSub(arg, self, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rdiv____SWIG_0(CvMat *self,CvArr *arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvDiv(arg, self, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rmul____SWIG_0(CvMat *self,CvArr *arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvMul(arg, self, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___radd____SWIG_1(CvMat *self,CvScalar arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvAddS(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___radd____SWIG_2(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvAddS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rsub____SWIG_1(CvMat *self,CvScalar arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvSubRS(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rsub____SWIG_2(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvSubRS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rmul____SWIG_1(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvConvertScale(self, retarg, arg);
return retarg;
}
SWIGINTERN CvMat *CvMat___ror____SWIG_0(CvMat *self,CvScalar arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvOrS(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___ror____SWIG_1(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvOrS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rand____SWIG_0(CvMat *self,CvScalar arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvAndS(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rand____SWIG_1(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvAndS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rxor____SWIG_0(CvMat *self,CvScalar arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvXorS(self, arg, retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___rxor____SWIG_1(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvXorS(self, cvScalar(arg), retarg);
return retarg;
}
SWIGINTERN CvMat *CvMat___req__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 0);
return retarg;
}
SWIGINTERN CvMat *CvMat___rgt__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 1);
return retarg;
}
SWIGINTERN CvMat *CvMat___rge__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 2);
return retarg;
}
SWIGINTERN CvMat *CvMat___rlt__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 3);
return retarg;
}
SWIGINTERN CvMat *CvMat___rle__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 4);
return retarg;
}
SWIGINTERN CvMat *CvMat___rne__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, 0);
cvCmpS(self, arg, retarg, 5);
return retarg;
}
SWIGINTERN CvMat *CvMat___rdiv____SWIG_1(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvDiv(NULL, self, retarg, arg);
return retarg;
}
SWIGINTERN CvMat *CvMat___pow__(CvMat *self,double arg){
CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type);
cvPow(self, retarg, arg);
return retarg;
}
SWIGINTERN char *CvMat___str__(CvMat *self){
static char str[8];
cvArrPrint( self );
str[0]=0;
return str;
}
SWIGINTERN void CvMat___setitem____SWIG_0(CvMat *self,PyObject *object,double val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return ;
}
else{}
/*@SWIG@*/;
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalarAll(val));
}
SWIGINTERN void CvMat___setitem____SWIG_1(CvMat *self,PyObject *object,CvPoint val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return ;
}
else{}
/*@SWIG@*/;
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
SWIGINTERN void CvMat___setitem____SWIG_2(CvMat *self,PyObject *object,CvPoint2D32f val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return ;
}
else{}
/*@SWIG@*/;
cvSet(&tmp, cvScalar(val.x, val.y));
}
SWIGINTERN void CvMat___setitem____SWIG_3(CvMat *self,PyObject *object,CvScalar val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return ;
}
else{}
/*@SWIG@*/;
cvSet(&tmp, val);
}
SWIGINTERN void CvMat___setitem____SWIG_4(CvMat *self,PyObject *object,CvArr *arr){
CvMat tmp, src_stub, *src;
CvRect subrect = PySlice_to_CvRect( self, object );
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return ;
}
else{}
/*@SWIG@*/;
cvGetSubRect(self, &tmp, subrect);
// Reshape source array to fit destination
// This will be used a lot for small arrays b/c
// PyObject_to_CvArr tries to compress a 2-D python
// array with 1-4 columns into a multichannel vector
src=cvReshape(arr, &src_stub, CV_MAT_CN(tmp.type), tmp.rows);
cvConvert(src, &tmp);
}
SWIGINTERN PyObject *CvMat___getitem__(CvMat *self,PyObject *object){
CvMat * mat;
CvRect subrect = PySlice_to_CvRect( self, object );
/*@SWIG:../../../../interfaces/swig/python/./cvarr.i,209,CHECK_SLICE_BOUNDS@*/
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
if(subrect.width<=0 || subrect.height<=0 ||
subrect.width>self->cols || subrect.height>self->rows ||
subrect.x<0 || subrect.y<0 ||
subrect.x>= self->cols || subrect.y >=self->rows){
char errstr[256];
// previous function already set error string
if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return NULL;
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return NULL;
}
else{}
/*@SWIG@*/;
if(subrect.width==1 && subrect.height==1){
CvScalar * s;
int type = cvGetElemType( self );
if(CV_MAT_CN(type) > 1){
s = new CvScalar;
*s = cvGet2D( self, subrect.y, subrect.x );
return SWIG_NewPointerObj( s, SWIGTYPE_p_CvScalar, 1 );
}
switch(CV_MAT_DEPTH(type)){
case 0:
return PyLong_FromUnsignedLong( CV_MAT_ELEM(*self, uchar, subrect.y, subrect.x ) );
case 1:
return PyLong_FromLong( CV_MAT_ELEM(*self, char, subrect.y, subrect.x ) );
case 2:
return PyLong_FromUnsignedLong( CV_MAT_ELEM(*self, ushort, subrect.y, subrect.x ) );
case 3:
return PyLong_FromLong( CV_MAT_ELEM(*self, short, subrect.y, subrect.x ) );
case 4:
return PyLong_FromLong( CV_MAT_ELEM(*self, int, subrect.y, subrect.x ) );
case 5:
return PyFloat_FromDouble( CV_MAT_ELEM(*self, float, subrect.y, subrect.x) );
case 6:
return PyFloat_FromDouble( CV_MAT_ELEM(*self, double, subrect.y, subrect.x) );
}
}
mat = (CvMat *) cvAlloc(sizeof(CvMat));
cvGetSubRect(self, mat, subrect);
// cvGetSubRect doesn't do this since it assumes mat lives on the stack
mat->hdr_refcount = self->hdr_refcount;
mat->refcount = self->refcount;
cvIncRefData(mat);
return SWIG_NewPointerObj( mat, SWIGTYPE_p_CvMat, 1 );
}
SWIGINTERN CvMat *CvMat___invert__(CvMat *self){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvNot( self, res );
return res;
}
typedef struct {
int size;
int step;
} CvMatND_dim;
typedef union {
uchar* ptr;
float* fl;
double* db;
int* i;
short* s;
} CvMatND_data;
SWIGINTERN void delete_CvMatND(CvMatND *self){ CvMatND * dummy = self; cvReleaseMatND (& dummy); }
SWIGINTERN void delete_CvSparseMat(CvSparseMat *self){ CvSparseMat * dummy = self; cvReleaseSparseMat (& dummy); }
SWIGINTERN void delete_CvHistogram(CvHistogram *self){ CvHistogram * dummy = self; cvReleaseHist (& dummy); }
SWIGINTERN char const *CvPoint___str__(CvPoint *self){
static char str[64];
snprintf(str, 64, "[%d %d]", self->x, self->y);
return str;
}
SWIGINTERN char const *CvPoint___repr__(CvPoint *self){
static char str[64];
snprintf(str, 64, "cvPoint(%d,%d)", self->x, self->y);
return str;
}
SWIGINTERN char const *CvPoint2D32f___str__(CvPoint2D32f *self){
static char str[64];
snprintf(str, 64, "[%f %f]", self->x, self->y);
return str;
}
SWIGINTERN char const *CvPoint2D32f___repr__(CvPoint2D32f *self){
static char str[64];
snprintf(str, 64, "cvPoint2D32f(%f,%f)", self->x, self->y);
return str;
}
SWIGINTERN char const *CvScalar___str__(CvScalar *self){
static char str[256];
snprintf(str, 256, "[%f, %f, %f, %f]", self->val[0], self->val[1], self->val[2], self->val[3]);
return str;
}
SWIGINTERN char const *CvScalar___repr__(CvScalar *self){
static char str[256];
snprintf(str, 256, "cvScalar(%f, %f, %f, %f)", self->val[0], self->val[1], self->val[2], self->val[3]);
return str;
}
SWIGINTERN double const CvScalar___getitem__(CvScalar *self,int index){
if (index >= 4) {
return 0;
}
if (index < -4) {
return 0;
}
if (index < 0) {
/* negative index means from the end in python */
index = 4 - index;
}
return self->val [index];
}
SWIGINTERN void CvScalar___setitem__(CvScalar *self,int index,double value){
if (index >= 4) {
return;
}
if (index < -4) {
return;
}
if (index < 0) {
/* negative index means from the end in python */
index = 4 - index;
}
self->val [index] = value;
}
SWIGINTERN void delete_CvMemStorage(CvMemStorage *self){ CvMemStorage * dummy = self; cvReleaseMemStorage (& dummy); }
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
if (PyString_Check(obj)) {
char *cstr; Py_ssize_t len;
PyString_AsStringAndSize(obj, &cstr, &len);
if (cptr) {
if (alloc) {
/*
In python the user should not be able to modify the inner
string representation. To warranty that, if you define
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
buffer is always returned.
The default behavior is just to return the pointer value,
so, be careful.
*/
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
if (*alloc != SWIG_OLDOBJ)
#else
if (*alloc == SWIG_NEWOBJ)
#endif
{
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
*alloc = SWIG_NEWOBJ;
}
else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
*cptr = PyString_AsString(obj);
}
}
if (psize) *psize = len + 1;
return SWIG_OK;
} else {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
typedef union {
double f;
int i;
CvString str;
CvSeq* seq;
CvFileNodeHash* map;
} CvFileNode_data;
SWIGINTERN void delete_CvGraphScanner(CvGraphScanner *self){ CvGraphScanner * dummy = self; cvReleaseGraphScanner (& dummy); }
SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
int r = PyObject_IsTrue(obj);
if (r == -1)
return SWIG_ERROR;
if (val) *val = r ? true : false;
return SWIG_OK;
}
SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{
char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
if (SWIG_IsOK(res)) {
if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
if (csize <= size) {
if (val) {
if (csize) memcpy(val, cptr, csize*sizeof(char));
if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
}
if (alloc == SWIG_NEWOBJ) {
delete[] cptr;
res = SWIG_DelNewMask(res);
}
return res;
}
if (alloc == SWIG_NEWOBJ) delete[] cptr;
}
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{
int res = SWIG_AsCharArray(obj, val, 1);
if (!SWIG_IsOK(res)) {
long v;
res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
if (SWIG_IsOK(res)) {
if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
if (val) *val = static_cast< char >(v);
} else {
res = SWIG_OverflowError;
}
}
}
return res;
}
SWIGINTERNINLINE PyObject *
SWIG_From_char (char c)
{
return SWIG_FromCharPtrAndSize(&c,1);
}
SWIGINTERN CvTypedSeq< CvQuadEdge2D > *CvSubdiv2D_typed_edges_get(CvSubdiv2D *self){
return (CvTypedSeq<CvQuadEdge2D> *) self->edges;
}
SWIGINTERN void CvSubdiv2D_typed_edges_set(CvSubdiv2D *self,CvTypedSeq< CvQuadEdge2D > *){
}
SWIGINTERN void delete_CvConDensation(CvConDensation *self){ CvConDensation * dummy = self; cvReleaseConDensation (& dummy); }
SWIGINTERN void delete_CvKalman(CvKalman *self){ CvKalman * dummy = self; cvReleaseKalman (& dummy); }
typedef struct {
CvRect r;
float weight;
} CvHaarFeature_rect;
SWIGINTERN void delete_CvHaarClassifierCascade(CvHaarClassifierCascade *self){ CvHaarClassifierCascade * dummy = self; cvReleaseHaarClassifierCascade (& dummy); }
int CvMat_cols_get(CvMat * m){
return m->cols;
}
int CvMat_rows_get(CvMat *m){
return m->rows;
}
int CvMat_width_get(CvMat * m){
return m->cols;
}
int CvMat_height_get(CvMat *m){
return m->rows;
}
int CvMat_depth_get(CvMat * m){
return cvCvToIplDepth(m->type);
}
int CvMat_nChannels_get(CvMat * m){
return CV_MAT_CN(m->type);
}
int CvMat_origin_get(CvMat * m){
return 0;
}
int CvMat_dataOrder_get(CvMat * m){
return 0;
}
int CvMat_imageSize_get(CvMat * m){
int step = m->step ? m->step :
step = CV_ELEM_SIZE(m->type) * m->cols;
return step*m->rows;
}
int CvMat_widthStep_get(CvMat * m){
return m->step;
}
/// Accessor to convert a Python string into the imageData.
void CvMat_imageData_set(CvMat * self, PyObject* object)
{
char* py_string = PyString_AsString(object);
int depth = CV_MAT_DEPTH(self->type);
int cn = CV_MAT_CN(self->type);
int step = self->step ? self->step :
step = CV_ELEM_SIZE(self->type) * self->cols;
if (depth == CV_8U && cn==3){
// RGB case
// The data is reordered beause OpenCV uses BGR instead of RGB
for (long line = 0; line < self->rows; ++line)
for (long pixel = 0; pixel < self->cols; ++pixel)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
long position = line*step + pixel*3;
long sourcepos = line*self->cols*3 + pixel*3;
self->data.ptr[position ] = py_string[sourcepos+2];
self->data.ptr[position+1] = py_string[sourcepos+1];
self->data.ptr[position+2] = py_string[sourcepos ];
}
}
else if (depth == CV_8U && cn==1)
{
// Grayscale 8bit case
for (long line = 0; line < self->rows; ++line)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols,
step
);
}
}
else if ( depth == CV_32F )
{
// float (32bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols*sizeof(float),
step
);
}
}
else if ( depth == CV_64F )
{
// double (64bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols*sizeof(double),
step
);
}
}
else
{
// make some noise
SendErrorToPython (SWIG_TypeError,
"CvMat_imageData_set",
"cannot convert string data to this image format",
__FILE__, __LINE__, NULL);
}
}
/// Accessor to convert the imageData into a Python string.
PyObject* CvMat_imageData_get(CvMat * self)
{
if (!self->data.ptr)
{
PyErr_SetString(PyExc_TypeError, "Data pointer of CvMat is NULL");
return NULL;
}
int step = self->step ? self->step :
step = CV_ELEM_SIZE(self->type) * self->cols;
return PyString_FromStringAndSize((const char *)self->data.ptr, self->rows*step);
}
#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_CvRNG_Wrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG *arg1 = 0 ;
CvRNG temp1 ;
uint64 val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvRNG_Wrapper *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvRNG_Wrapper",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvRNG_Wrapper" "', argument " "1"" of type '" "CvRNG""'");
}
temp1 = static_cast< CvRNG >(val1);
arg1 = &temp1;
result = (CvRNG_Wrapper *)new CvRNG_Wrapper((CvRNG const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRNG_Wrapper, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRNG_Wrapper_ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRNG *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvRNG_Wrapper_ptr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper_ptr" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
}
arg1 = reinterpret_cast< CvRNG_Wrapper * >(argp1);
result = (CvRNG *)(arg1)->ptr();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long_long, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRNG_Wrapper_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRNG *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvRNG_Wrapper_ref",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper_ref" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
}
arg1 = reinterpret_cast< CvRNG_Wrapper * >(argp1);
{
CvRNG &_result_ref = (arg1)->ref();
result = (CvRNG *) &_result_ref;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long_long, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRNG_Wrapper___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
CvRNG_Wrapper *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRNG_Wrapper___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper___eq__" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
}
arg1 = reinterpret_cast< CvRNG_Wrapper * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRNG_Wrapper, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRNG_Wrapper___eq__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRNG_Wrapper___eq__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
}
arg2 = reinterpret_cast< CvRNG_Wrapper * >(argp2);
result = (bool)(arg1)->operator ==((CvRNG_Wrapper const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRNG_Wrapper___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
CvRNG_Wrapper *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRNG_Wrapper___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper___ne__" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
}
arg1 = reinterpret_cast< CvRNG_Wrapper * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRNG_Wrapper, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRNG_Wrapper___ne__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRNG_Wrapper___ne__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
}
arg2 = reinterpret_cast< CvRNG_Wrapper * >(argp2);
result = (bool)(arg1)->operator !=((CvRNG_Wrapper const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvRNG_Wrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvRNG_Wrapper",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRNG_Wrapper, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRNG_Wrapper" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
}
arg1 = reinterpret_cast< CvRNG_Wrapper * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvRNG_Wrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvRNG_Wrapper, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvSubdiv2DEdge_Wrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge *arg1 = 0 ;
CvSubdiv2DEdge temp1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge_Wrapper *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvSubdiv2DEdge_Wrapper",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSubdiv2DEdge_Wrapper" "', argument " "1"" of type '" "CvSubdiv2DEdge""'");
}
temp1 = static_cast< CvSubdiv2DEdge >(val1);
arg1 = &temp1;
result = (CvSubdiv2DEdge_Wrapper *)new CvSubdiv2DEdge_Wrapper((CvSubdiv2DEdge const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DEdge_Wrapper_ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2DEdge_Wrapper_ptr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper_ptr" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp1);
result = (CvSubdiv2DEdge *)(arg1)->ptr();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_size_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DEdge_Wrapper_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2DEdge_Wrapper_ref",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper_ref" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp1);
{
CvSubdiv2DEdge &_result_ref = (arg1)->ref();
result = (CvSubdiv2DEdge *) &_result_ref;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_size_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DEdge_Wrapper___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
CvSubdiv2DEdge_Wrapper *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2DEdge_Wrapper___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
}
arg2 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp2);
result = (bool)(arg1)->operator ==((CvSubdiv2DEdge_Wrapper const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DEdge_Wrapper___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
CvSubdiv2DEdge_Wrapper *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2DEdge_Wrapper___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
}
arg2 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp2);
result = (bool)(arg1)->operator !=((CvSubdiv2DEdge_Wrapper const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSubdiv2DEdge_Wrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSubdiv2DEdge_Wrapper",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2DEdge_Wrapper" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DEdge_Wrapper * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSubdiv2DEdge_Wrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
try {
result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
size_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
result = (swig::PySwigIterator *)(arg1)->incr(arg2);
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
try {
result = (swig::PySwigIterator *)(arg1)->incr();
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_PySwigIterator_incr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_PySwigIterator_incr__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
" Possible C/C++ prototypes are:\n"
" incr(swig::PySwigIterator *,size_t)\n"
" incr(swig::PySwigIterator *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
size_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
try {
result = (swig::PySwigIterator *)(arg1)->decr(arg2);
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
try {
result = (swig::PySwigIterator *)(arg1)->decr();
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_PySwigIterator_decr__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_PySwigIterator_decr__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
" Possible C/C++ prototypes are:\n"
" decr(swig::PySwigIterator *,size_t)\n"
" decr(swig::PySwigIterator *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
swig::PySwigIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ptrdiff_t result;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
try {
result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
}
catch(std::invalid_argument &_e) {
SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
}
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
swig::PySwigIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
try {
result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
}
catch(std::invalid_argument &_e) {
SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
try {
result = (PyObject *)(arg1)->next();
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
try {
result = (PyObject *)(arg1)->previous();
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::PySwigIterator *)(arg1)->advance(arg2);
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
swig::PySwigIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
swig::PySwigIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
{
swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
result = (swig::PySwigIterator *) &_result_ref;
}
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
{
swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
result = (swig::PySwigIterator *) &_result_ref;
}
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
ptrdiff_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
swig::PySwigIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
}
arg2 = static_cast< ptrdiff_t >(val2);
try {
result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
}
catch(swig::stop_iteration &_e) {
{
(void)_e;
SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
swig::PySwigIterator *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
ptrdiff_t result;
if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
}
arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
}
arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_PySwigIterator___sub____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_PySwigIterator___sub____SWIG_0(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_FloatVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::PySwigIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_iterator" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (swig::PySwigIterator *)std_vector_Sl_float_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___nonzero__" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (bool)std_vector_Sl_float_Sg____nonzero__((std::vector< float > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___len__" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = std_vector_Sl_float_Sg____len__((std::vector< float > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_pop" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
try {
result = (std::vector< float >::value_type)std_vector_Sl_float_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
std::vector< float >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< float,std::allocator< float > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___getslice__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___getslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___getslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'");
}
arg3 = static_cast< std::vector< float >::difference_type >(val3);
try {
result = (std::vector< float,std::allocator< float > > *)std_vector_Sl_float_Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
std::vector< float >::difference_type arg3 ;
std::vector< float,std::allocator< float > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
int res4 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___setslice__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___setslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___setslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'");
}
arg3 = static_cast< std::vector< float >::difference_type >(val3);
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FloatVector___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_float_Sg____setslice__(arg1,arg2,arg3,(std::vector< float,std::allocator< float > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
catch(std::invalid_argument &_e) {
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res4)) delete arg4;
return resultobj;
fail:
if (SWIG_IsNewObj(res4)) delete arg4;
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
std::vector< float >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___delslice__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___delslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___delslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'");
}
arg3 = static_cast< std::vector< float >::difference_type >(val3);
try {
std_vector_Sl_float_Sg____delslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___delitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___delitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
try {
std_vector_Sl_float_Sg____delitem__(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< float >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___getitem__" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___getitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
try {
{
std::vector< float >::value_type const &_result_ref = std_vector_Sl_float_Sg____getitem__((std::vector< float > const *)arg1,arg2);
result = (std::vector< float >::value_type *) &_result_ref;
}
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::difference_type arg2 ;
std::vector< float >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
std::vector< float >::value_type temp3 ;
float val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___setitem__" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___setitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'");
}
arg2 = static_cast< std::vector< float >::difference_type >(val2);
ecode3 = SWIG_AsVal_float(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___setitem__" "', argument " "3"" of type '" "std::vector< float >::value_type""'");
}
temp3 = static_cast< std::vector< float >::value_type >(val3);
arg3 = &temp3;
try {
std_vector_Sl_float_Sg____setitem__(arg1,arg2,(float const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< float >::value_type temp2 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_append" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_append" "', argument " "2"" of type '" "std::vector< float >::value_type""'");
}
temp2 = static_cast< std::vector< float >::value_type >(val2);
arg2 = &temp2;
std_vector_Sl_float_Sg__append(arg1,(float const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_FloatVector")) SWIG_fail;
result = (std::vector< float > *)new std::vector< float >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_FloatVector",&obj0)) SWIG_fail;
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'");
}
arg1 = ptr;
}
result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_empty" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = (bool)((std::vector< float > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_size" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_clear" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_swap" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatVector_swap" "', argument " "2"" of type '" "std::vector< float > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector_swap" "', argument " "2"" of type '" "std::vector< float > &""'");
}
arg2 = reinterpret_cast< std::vector< float > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< float > > result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_get_allocator" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< float >::allocator_type(static_cast< const std::vector< float >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_begin" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::const_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_end" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::const_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_rbegin" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::const_reverse_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_rend" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::const_reverse_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_FloatVector",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float >::size_type""'");
}
arg1 = static_cast< std::vector< float >::size_type >(val1);
result = (std::vector< float > *)new std::vector< float >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_pop_back" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_resize" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_resize" "', argument " "2"" of type '" "std::vector< float >::size_type""'");
}
arg2 = static_cast< std::vector< float >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< float >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_erase" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
result = (arg1)->erase(arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::iterator arg2 ;
std::vector< float >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
swig::PySwigIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< float >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_erase" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_erase(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_FloatVector_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_FloatVector_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector_erase'.\n"
" Possible C/C++ prototypes are:\n"
" erase(std::vector< float > *,std::vector< float >::iterator)\n"
" erase(std::vector< float > *,std::vector< float >::iterator,std::vector< float >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float >::size_type arg1 ;
std::vector< float >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
std::vector< float >::value_type temp2 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< float > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatVector",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float >::size_type""'");
}
arg1 = static_cast< std::vector< float >::size_type >(val1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatVector" "', argument " "2"" of type '" "std::vector< float >::value_type""'");
}
temp2 = static_cast< std::vector< float >::value_type >(val2);
arg2 = &temp2;
result = (std::vector< float > *)new std::vector< float >(arg1,(std::vector< float >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_FloatVector(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_FloatVector__SWIG_0(self, args);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_size_t(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_FloatVector__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_FloatVector__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_size_t(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_float(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_FloatVector__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FloatVector'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< float >()\n"
" std::vector< float >(std::vector< float > const &)\n"
" std::vector< float >(std::vector< float >::size_type)\n"
" std::vector< float >(std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< float >::value_type temp2 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_push_back" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_push_back" "', argument " "2"" of type '" "std::vector< float >::value_type""'");
}
temp2 = static_cast< std::vector< float >::value_type >(val2);
arg2 = &temp2;
(arg1)->push_back((std::vector< float >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_front" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
std::vector< float >::value_type const &_result_ref = ((std::vector< float > const *)arg1)->front();
result = (std::vector< float >::value_type *) &_result_ref;
}
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_back" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
std::vector< float >::value_type const &_result_ref = ((std::vector< float > const *)arg1)->back();
result = (std::vector< float >::value_type *) &_result_ref;
}
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::size_type arg2 ;
std::vector< float >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< float >::value_type temp3 ;
float val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_assign" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_assign" "', argument " "2"" of type '" "std::vector< float >::size_type""'");
}
arg2 = static_cast< std::vector< float >::size_type >(val2);
ecode3 = SWIG_AsVal_float(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_assign" "', argument " "3"" of type '" "std::vector< float >::value_type""'");
}
temp3 = static_cast< std::vector< float >::value_type >(val3);
arg3 = &temp3;
(arg1)->assign(arg2,(std::vector< float >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::size_type arg2 ;
std::vector< float >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
std::vector< float >::value_type temp3 ;
float val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_resize" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_resize" "', argument " "2"" of type '" "std::vector< float >::size_type""'");
}
arg2 = static_cast< std::vector< float >::size_type >(val2);
ecode3 = SWIG_AsVal_float(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_resize" "', argument " "3"" of type '" "std::vector< float >::value_type""'");
}
temp3 = static_cast< std::vector< float >::value_type >(val3);
arg3 = &temp3;
(arg1)->resize(arg2,(std::vector< float >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_resize(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_FloatVector_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_float(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_FloatVector_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector_resize'.\n"
" Possible C/C++ prototypes are:\n"
" resize(std::vector< float > *,std::vector< float >::size_type)\n"
" resize(std::vector< float > *,std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::iterator arg2 ;
std::vector< float >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
std::vector< float >::value_type temp3 ;
float val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< float >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_insert" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
ecode3 = SWIG_AsVal_float(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_insert" "', argument " "3"" of type '" "std::vector< float >::value_type""'");
}
temp3 = static_cast< std::vector< float >::value_type >(val3);
arg3 = &temp3;
result = (arg1)->insert(arg2,(std::vector< float >::value_type const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< float >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::iterator arg2 ;
std::vector< float >::size_type arg3 ;
std::vector< float >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
std::vector< float >::value_type temp4 ;
float val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_insert" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< float >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_insert" "', argument " "3"" of type '" "std::vector< float >::size_type""'");
}
arg3 = static_cast< std::vector< float >::size_type >(val3);
ecode4 = SWIG_AsVal_float(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatVector_insert" "', argument " "4"" of type '" "std::vector< float >::value_type""'");
}
temp4 = static_cast< std::vector< float >::value_type >(val4);
arg4 = &temp4;
(arg1)->insert(arg2,arg3,(std::vector< float >::value_type const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_insert(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_float(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_FloatVector_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< float >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_float(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_FloatVector_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector_insert'.\n"
" Possible C/C++ prototypes are:\n"
" insert(std::vector< float > *,std::vector< float >::iterator,std::vector< float >::value_type const &)\n"
" insert(std::vector< float > *,std::vector< float >::iterator,std::vector< float >::size_type,std::vector< float >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
std::vector< float >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_reserve" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_reserve" "', argument " "2"" of type '" "std::vector< float >::size_type""'");
}
arg2 = static_cast< std::vector< float >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_FloatVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< float >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_capacity" "', argument " "1"" of type '" "std::vector< float > const *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
result = ((std::vector< float > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_FloatVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< float > *arg1 = (std::vector< float > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatVector",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatVector" "', argument " "1"" of type '" "std::vector< float > *""'");
}
arg1 = reinterpret_cast< std::vector< float > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *FloatVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvPointVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
PyObject **arg2 = (PyObject **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
swig::PySwigIterator *result = 0 ;
arg2 = &obj0;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_iterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_iterator" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = (swig::PySwigIterator *)std_vector_Sl_CvPoint_Sg__iterator(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector___nonzero__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___nonzero__" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = (bool)std_vector_Sl_CvPoint_Sg____nonzero__((std::vector< CvPoint > const *)arg1);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector___len__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___len__" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = std_vector_Sl_CvPoint_Sg____len__((std::vector< CvPoint > const *)arg1);
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::value_type result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_pop" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
try {
result = std_vector_Sl_CvPoint_Sg__pop(arg1);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj((new std::vector< CvPoint >::value_type(static_cast< const std::vector< CvPoint >::value_type& >(result))), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
std::vector< CvPoint >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< CvPoint,std::allocator< CvPoint > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___getslice__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___getslice__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvPointVector___getslice__" "', argument " "3"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg3 = static_cast< std::vector< CvPoint >::difference_type >(val3);
try {
result = (std::vector< CvPoint,std::allocator< CvPoint > > *)std_vector_Sl_CvPoint_Sg____getslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
std::vector< CvPoint >::difference_type arg3 ;
std::vector< CvPoint,std::allocator< CvPoint > > *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
int res4 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvPointVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___setslice__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___setslice__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvPointVector___setslice__" "', argument " "3"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg3 = static_cast< std::vector< CvPoint >::difference_type >(val3);
{
std::vector<CvPoint,std::allocator< CvPoint > > *ptr = (std::vector<CvPoint,std::allocator< CvPoint > > *)0;
res4 = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvPointVector___setslice__" "', argument " "4"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector___setslice__" "', argument " "4"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > > const &""'");
}
arg4 = ptr;
}
try {
std_vector_Sl_CvPoint_Sg____setslice__(arg1,arg2,arg3,(std::vector< CvPoint,std::allocator< CvPoint > > const &)*arg4);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
catch(std::invalid_argument &_e) {
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res4)) delete arg4;
return resultobj;
fail:
if (SWIG_IsNewObj(res4)) delete arg4;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
std::vector< CvPoint >::difference_type arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
ptrdiff_t val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___delslice__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___delslice__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvPointVector___delslice__" "', argument " "3"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg3 = static_cast< std::vector< CvPoint >::difference_type >(val3);
try {
std_vector_Sl_CvPoint_Sg____delslice__(arg1,arg2,arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector___delitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___delitem__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___delitem__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
try {
std_vector_Sl_CvPoint_Sg____delitem__(arg1,arg2);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< CvPoint >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___getitem__" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___getitem__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
try {
{
std::vector< CvPoint >::value_type const &_result_ref = std_vector_Sl_CvPoint_Sg____getitem__((std::vector< CvPoint > const *)arg1,arg2);
result = (std::vector< CvPoint >::value_type *) &_result_ref;
}
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::difference_type arg2 ;
std::vector< CvPoint >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
ptrdiff_t val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___setitem__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___setitem__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::difference_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector___setitem__" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector___setitem__" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp3);
try {
std_vector_Sl_CvPoint_Sg____setitem__(arg1,arg2,(CvPoint const &)*arg3);
}
catch(std::out_of_range &_e) {
SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_append" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPointVector_append" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_append" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp2);
std_vector_Sl_CvPoint_Sg__append(arg1,(CvPoint const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPointVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPointVector")) SWIG_fail;
result = (std::vector< CvPoint > *)new std::vector< CvPoint >();
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPointVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = 0 ;
int res1 = SWIG_OLDOBJ ;
PyObject * obj0 = 0 ;
std::vector< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvPointVector",&obj0)) SWIG_fail;
{
std::vector<CvPoint,std::allocator< CvPoint > > *ptr = (std::vector<CvPoint,std::allocator< CvPoint > > *)0;
res1 = swig::asptr(obj0, &ptr);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > const &""'");
}
if (!ptr) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > const &""'");
}
arg1 = ptr;
}
result = (std::vector< CvPoint > *)new std::vector< CvPoint >((std::vector< CvPoint > const &)*arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_NEW | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
fail:
if (SWIG_IsNewObj(res1)) delete arg1;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_empty",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_empty" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = (bool)((std::vector< CvPoint > const *)arg1)->empty();
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_size" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->size();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_clear" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
(arg1)->clear();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_swap",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_swap" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPointVector_swap" "', argument " "2"" of type '" "std::vector< CvPoint > &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_swap" "', argument " "2"" of type '" "std::vector< CvPoint > &""'");
}
arg2 = reinterpret_cast< std::vector< CvPoint > * >(argp2);
(arg1)->swap(*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
SwigValueWrapper< std::allocator< CvPoint > > result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_get_allocator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_get_allocator" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->get_allocator();
resultobj = SWIG_NewPointerObj((new std::vector< CvPoint >::allocator_type(static_cast< const std::vector< CvPoint >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_begin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_begin" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->begin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::const_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::const_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_end",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_end" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->end();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::const_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_rbegin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_rbegin" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->rbegin();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::const_reverse_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::const_reverse_iterator result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_rend",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_rend" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->rend();
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::const_reverse_iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPointVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint >::size_type arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvPointVector",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg1 = static_cast< std::vector< CvPoint >::size_type >(val1);
result = (std::vector< CvPoint > *)new std::vector< CvPoint >(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_pop_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_pop_back" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
(arg1)->pop_back();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_resize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_resize" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_resize" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::size_type >(val2);
(arg1)->resize(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::iterator arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< CvPoint >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_erase",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_erase" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
}
}
result = (arg1)->erase(arg2);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::iterator arg2 ;
std::vector< CvPoint >::iterator arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
swig::PySwigIterator *iter3 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< CvPoint >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_erase" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res3) || !iter3) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "3"" of type '" "std::vector< CvPoint >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter3);
if (iter_t) {
arg3 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "3"" of type '" "std::vector< CvPoint >::iterator""'");
}
}
result = (arg1)->erase(arg2,arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_erase(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_CvPointVector_erase__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter) != 0));
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter) != 0));
if (_v) {
return _wrap_CvPointVector_erase__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvPointVector_erase'.\n"
" Possible C/C++ prototypes are:\n"
" erase(std::vector< CvPoint > *,std::vector< CvPoint >::iterator)\n"
" erase(std::vector< CvPoint > *,std::vector< CvPoint >::iterator,std::vector< CvPoint >::iterator)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPointVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint >::size_type arg1 ;
std::vector< CvPoint >::value_type *arg2 = 0 ;
size_t val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
std::vector< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_CvPointVector",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg1 = static_cast< std::vector< CvPoint >::size_type >(val1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvPointVector" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvPointVector" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp2);
result = (std::vector< CvPoint > *)new std::vector< CvPoint >(arg1,(std::vector< CvPoint >::value_type const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPointVector(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvPointVector__SWIG_0(self, args);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_size_t(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvPointVector__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvPointVector__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_size_t(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvPointVector__SWIG_3(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvPointVector'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< CvPoint >()\n"
" std::vector< CvPoint >(std::vector< CvPoint > const &)\n"
" std::vector< CvPoint >(std::vector< CvPoint >::size_type)\n"
" std::vector< CvPoint >(std::vector< CvPoint >::size_type,std::vector< CvPoint >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::value_type *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_push_back",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_push_back" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPointVector_push_back" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_push_back" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg2 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp2);
(arg1)->push_back((std::vector< CvPoint >::value_type const &)*arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_front",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_front" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
{
std::vector< CvPoint >::value_type const &_result_ref = ((std::vector< CvPoint > const *)arg1)->front();
result = (std::vector< CvPoint >::value_type *) &_result_ref;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::value_type *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_back",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_back" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
{
std::vector< CvPoint >::value_type const &_result_ref = ((std::vector< CvPoint > const *)arg1)->back();
result = (std::vector< CvPoint >::value_type *) &_result_ref;
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::size_type arg2 ;
std::vector< CvPoint >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_assign" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_assign" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::size_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_assign" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_assign" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp3);
(arg1)->assign(arg2,(std::vector< CvPoint >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::size_type arg2 ;
std::vector< CvPoint >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_resize" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_resize" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::size_type >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_resize" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_resize" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp3);
(arg1)->resize(arg2,(std::vector< CvPoint >::value_type const &)*arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_resize(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvPointVector_resize__SWIG_0(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvPointVector_resize__SWIG_1(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvPointVector_resize'.\n"
" Possible C/C++ prototypes are:\n"
" resize(std::vector< CvPoint > *,std::vector< CvPoint >::size_type)\n"
" resize(std::vector< CvPoint > *,std::vector< CvPoint >::size_type,std::vector< CvPoint >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::iterator arg2 ;
std::vector< CvPoint >::value_type *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
std::vector< CvPoint >::iterator result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvPointVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_insert" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
}
}
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg3 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp3);
result = (arg1)->insert(arg2,(std::vector< CvPoint >::value_type const &)*arg3);
resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< CvPoint >::iterator & >(result)),
swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::iterator arg2 ;
std::vector< CvPoint >::size_type arg3 ;
std::vector< CvPoint >::value_type *arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
swig::PySwigIterator *iter2 = 0 ;
int res2 ;
size_t val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvPointVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_insert" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
if (!SWIG_IsOK(res2) || !iter2) {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
} else {
swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter2);
if (iter_t) {
arg2 = iter_t->get_current();
} else {
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'");
}
}
ecode3 = SWIG_AsVal_size_t(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg3 = static_cast< std::vector< CvPoint >::size_type >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvPointVector_insert" "', argument " "4"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_insert" "', argument " "4"" of type '" "std::vector< CvPoint >::value_type const &""'");
}
arg4 = reinterpret_cast< std::vector< CvPoint >::value_type * >(argp4);
(arg1)->insert(arg2,arg3,(std::vector< CvPoint >::value_type const &)*arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_insert(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter) != 0));
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvPointVector_insert__SWIG_0(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = swig::asptr(argv[0], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
swig::PySwigIterator *iter = 0;
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< CvPoint >::iterator > *>(iter) != 0));
if (_v) {
{
int res = SWIG_AsVal_size_t(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvPointVector_insert__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvPointVector_insert'.\n"
" Possible C/C++ prototypes are:\n"
" insert(std::vector< CvPoint > *,std::vector< CvPoint >::iterator,std::vector< CvPoint >::value_type const &)\n"
" insert(std::vector< CvPoint > *,std::vector< CvPoint >::iterator,std::vector< CvPoint >::size_type,std::vector< CvPoint >::value_type const &)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
std::vector< CvPoint >::size_type arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPointVector_reserve",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_reserve" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_reserve" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'");
}
arg2 = static_cast< std::vector< CvPoint >::size_type >(val2);
(arg1)->reserve(arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPointVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
std::vector< CvPoint >::size_type result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPointVector_capacity",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_capacity" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
result = ((std::vector< CvPoint > const *)arg1)->capacity();
resultobj = SWIG_From_size_t(static_cast< size_t >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPointVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPointVector",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > *""'");
}
arg1 = reinterpret_cast< std::vector< CvPoint > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPointVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvCvtSeqToArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSlice arg3 ;
void *ptr1 ;
bool freearg2 = false ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvArr *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCvtSeqToArray",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCvtSeqToArray" "', argument " "3"" of type '" "CvSlice""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCvtSeqToArray" "', argument " "3"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
result = (CvArr *)cvCvtSeqToArray_Shadow((CvSeq const *)arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCvtSeqToArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *ptr1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvArr *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCvtSeqToArray",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
result = (CvArr *)cvCvtSeqToArray_Shadow((CvSeq const *)arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCvtSeqToArray(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_cvCvtSeqToArray__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvSlice, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvCvtSeqToArray__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvCvtSeqToArray'.\n"
" Possible C/C++ prototypes are:\n"
" cvCvtSeqToArray_Shadow(CvSeq const *,CvArr *,CvSlice)\n"
" cvCvtSeqToArray_Shadow(CvSeq const *,CvArr *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSlice arg2 ;
int arg3 ;
void *ptr1 ;
void *argp2 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvArcLength",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvArcLength" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double)cvArcLength_Shadow((CvSeq const *)arg1,arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSlice arg2 ;
void *ptr1 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvArcLength",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (double)cvArcLength_Shadow((CvSeq const *)arg1,arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvArcLength",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (double)cvArcLength_Shadow((CvSeq const *)arg1);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvSlice arg2 ;
int arg3 ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvArcLength",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvArcLength" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (double)cvArcLength_Shadow((void const *)arg1,arg2,arg3);
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvSlice arg2 ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvArcLength",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
result = (double)cvArcLength_Shadow((void const *)arg1,arg2);
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvArcLength",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
result = (double)cvArcLength_Shadow((void const *)arg1);
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvArcLength(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvArcLength__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_cvArcLength__SWIG_5(self, args);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CvSlice, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvArcLength__SWIG_4(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CvSlice, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvArcLength__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CvSlice, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvArcLength__SWIG_0(self, args);
}
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_CvSlice, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvArcLength__SWIG_3(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvArcLength'.\n"
" Possible C/C++ prototypes are:\n"
" cvArcLength_Shadow(CvSeq const *,CvSlice,int)\n"
" cvArcLength_Shadow(CvSeq const *,CvSlice)\n"
" cvArcLength_Shadow(CvSeq const *)\n"
" cvArcLength_Shadow(CvArr const *,CvSlice,int)\n"
" cvArcLength_Shadow(CvArr const *,CvSlice)\n"
" cvArcLength_Shadow(CvArr const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvContourPerimeter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvContourPerimeter",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (double)cvContourPerimeter_Shadow(arg1);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvContourPerimeter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvContourPerimeter",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
result = (double)cvContourPerimeter_Shadow(arg1);
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvContourPerimeter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[2];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvContourPerimeter__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_cvContourPerimeter__SWIG_1(self, args);
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvContourPerimeter'.\n"
" Possible C/C++ prototypes are:\n"
" cvContourPerimeter_Shadow(CvSeq *)\n"
" cvContourPerimeter_Shadow(CvArr *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
double arg4 ;
int arg5 ;
int arg6 ;
CvSize arg7 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
void *argp7 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cvHaarDetectObjects",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHaarClassifierCascade * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvHaarDetectObjects" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvHaarDetectObjects" "', argument " "7"" of type '" "CvSize""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvHaarDetectObjects" "', argument " "7"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
double arg4 ;
int arg5 ;
int arg6 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvHaarDetectObjects",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHaarClassifierCascade * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvHaarDetectObjects" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
double arg4 ;
int arg5 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvHaarDetectObjects",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHaarClassifierCascade * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
double arg4 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvHaarDetectObjects",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHaarClassifierCascade * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvHaarDetectObjects",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHaarClassifierCascade * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHaarDetectObjects(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[8];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 7); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvHaarDetectObjects__SWIG_4(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvHaarDetectObjects__SWIG_3(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvHaarDetectObjects__SWIG_2(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvHaarDetectObjects__SWIG_1(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvHaarDetectObjects__SWIG_0(self, args);
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvHaarDetectObjects'.\n"
" Possible C/C++ prototypes are:\n"
" cvHaarDetectObjects_Shadow(CvArr const *,CvHaarClassifierCascade *,CvMemStorage *,double,int,int,CvSize)\n"
" cvHaarDetectObjects_Shadow(CvArr const *,CvHaarClassifierCascade *,CvMemStorage *,double,int,int)\n"
" cvHaarDetectObjects_Shadow(CvArr const *,CvHaarClassifierCascade *,CvMemStorage *,double,int)\n"
" cvHaarDetectObjects_Shadow(CvArr const *,CvHaarClassifierCascade *,CvMemStorage *,double)\n"
" cvHaarDetectObjects_Shadow(CvArr const *,CvHaarClassifierCascade *,CvMemStorage *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSegmentMotion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
double arg4 ;
double arg5 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvTypedSeq< CvConnectedComp > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSegmentMotion",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSegmentMotion" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSegmentMotion" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSegmentMotion" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
result = (CvTypedSeq< CvConnectedComp > *)cvSegmentMotion_Shadow((void const *)arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvApproxPoly__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int arg2 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
int arg4 ;
double arg5 ;
int arg6 ;
int res1 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvTypedSeq< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvApproxPoly",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvApproxPoly" "', argument " "1"" of type '" "void const *""'");
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvApproxPoly" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvApproxPoly" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvApproxPoly" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvApproxPoly" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvApproxPoly" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
result = (CvTypedSeq< CvPoint > *)cvApproxPoly_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvApproxPoly__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int arg2 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
int arg4 ;
double arg5 ;
int res1 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvTypedSeq< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvApproxPoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvApproxPoly" "', argument " "1"" of type '" "void const *""'");
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvApproxPoly" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvApproxPoly" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvApproxPoly" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvApproxPoly" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
result = (CvTypedSeq< CvPoint > *)cvApproxPoly_Shadow((void const *)arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvApproxPoly(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[7];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 5) {
int _v;
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvApproxPoly__SWIG_1(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvApproxPoly__SWIG_0(self, args);
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvApproxPoly'.\n"
" Possible C/C++ prototypes are:\n"
" cvApproxPoly_Shadow(void const *,int,CvMemStorage *,int,double,int)\n"
" cvApproxPoly_Shadow(void const *,int,CvMemStorage *,int,double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvexHull2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvConvexHull2",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvConvexHull2" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvConvexHull2" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvexHull2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvConvexHull2",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvConvexHull2" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvexHull2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvConvexHull2",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvexHull2(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_cvConvexHull2__SWIG_2(self, args);
}
}
if (argc == 2) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvConvexHull2__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
{
void *ptr;
if (argv[0] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[0]) || PyTuple_Check(argv[0])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvConvexHull2__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvConvexHull2'.\n"
" Possible C/C++ prototypes are:\n"
" cvConvexHull2_Shadow(CvArr const *,int,int)\n"
" cvConvexHull2_Shadow(CvArr const *,int)\n"
" cvConvexHull2_Shadow(CvArr const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSnakeImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
std::vector< CvPoint,std::allocator< CvPoint > > arg2 ;
std::vector< float,std::allocator< float > > arg3 ;
std::vector< float,std::allocator< float > > arg4 ;
std::vector< float,std::allocator< float > > arg5 ;
CvSize arg6 ;
CvTermCriteria arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp6 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
std::vector< CvPoint,std::allocator< CvPoint > > result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cvSnakeImage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSnakeImage" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
std::vector<CvPoint,std::allocator< CvPoint > > *ptr = (std::vector<CvPoint,std::allocator< CvPoint > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "2"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > >""'");
}
arg2 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg3 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg4 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "5"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg5 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvSnakeImage" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
result = cvSnakeImage_Shadow((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
resultobj = swig::from(static_cast< std::vector<CvPoint,std::allocator< CvPoint > > >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSnakeImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
std::vector< CvPoint,std::allocator< CvPoint > > arg2 ;
std::vector< float,std::allocator< float > > arg3 ;
std::vector< float,std::allocator< float > > arg4 ;
std::vector< float,std::allocator< float > > arg5 ;
CvSize arg6 ;
CvTermCriteria arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp6 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
std::vector< CvPoint,std::allocator< CvPoint > > result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cvSnakeImage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSnakeImage" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
std::vector<CvPoint,std::allocator< CvPoint > > *ptr = (std::vector<CvPoint,std::allocator< CvPoint > > *)0;
int res = swig::asptr(obj1, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "2"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > >""'");
}
arg2 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj2, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg3 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj3, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg4 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
std::vector<float,std::allocator< float > > *ptr = (std::vector<float,std::allocator< float > > *)0;
int res = swig::asptr(obj4, &ptr);
if (!SWIG_IsOK(res) || !ptr) {
SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "5"" of type '" "std::vector< float,std::allocator< float > >""'");
}
arg5 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
result = cvSnakeImage_Shadow((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
resultobj = swig::from(static_cast< std::vector<CvPoint,std::allocator< CvPoint > > >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSnakeImage(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[9];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 8); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[1], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[2], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[3], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[4], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvSnakeImage__SWIG_1(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[1], (std::vector<CvPoint,std::allocator< CvPoint > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[2], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[3], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = swig::asptr(argv[4], (std::vector<float,std::allocator< float > >**)(0));
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvSnakeImage__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvSnakeImage'.\n"
" Possible C/C++ prototypes are:\n"
" cvSnakeImage_Shadow(CvMat const *,std::vector< CvPoint,std::allocator< CvPoint > >,std::vector< float,std::allocator< float > >,std::vector< float,std::allocator< float > >,std::vector< float,std::allocator< float > >,CvSize,CvTermCriteria,int)\n"
" cvSnakeImage_Shadow(CvMat const *,std::vector< CvPoint,std::allocator< CvPoint > >,std::vector< float,std::allocator< float > >,std::vector< float,std::allocator< float > >,std::vector< float,std::allocator< float > >,CvSize,CvTermCriteria)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseImage",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseImage_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseMat",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseMat_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseStructuringElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseStructuringElement",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseStructuringElement_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseConDensation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseConDensation",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseConDensation_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseKalman(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseKalman",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseKalman_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseHist",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseHist_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseHaarClassifierCascade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseHaarClassifierCascade",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseHaarClassifierCascade_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleasePOSITObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleasePOSITObject",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleasePOSITObject_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseImageHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseImageHeader",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseImageHeader_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseMatND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseMatND",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseMatND_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseSparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseSparseMat",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseSparseMat_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseMemStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseMemStorage",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseMemStorage_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseGraphScanner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseGraphScanner",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseGraphScanner_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseFileStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseFileStorage",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseFileStorage_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRelease(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvRelease",&obj0)) SWIG_fail;
arg1 = obj0;
cvRelease_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseCapture",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseCapture_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseVideoWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
PyObject *arg1 = (PyObject *) 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseVideoWriter",&obj0)) SWIG_fail;
arg1 = obj0;
cvReleaseVideoWriter_Shadow(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **arg1 = (void **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvFree",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_void, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFree" "', argument " "1"" of type '" "void **""'");
}
arg1 = reinterpret_cast< void ** >(argp1);
cvFree(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_READ_CHAIN_POINT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvChainPtReader arg2 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_READ_CHAIN_POINT",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvChainPtReader, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_READ_CHAIN_POINT" "', argument " "2"" of type '" "CvChainPtReader""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_CHAIN_POINT" "', argument " "2"" of type '" "CvChainPtReader""'");
} else {
CvChainPtReader * temp = reinterpret_cast< CvChainPtReader * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_READ_CHAIN_POINT(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAT_ELEM_PTR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat arg1 ;
int arg2 ;
int arg3 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CV_MAT_ELEM_PTR",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvMat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_MAT_ELEM_PTR" "', argument " "1"" of type '" "CvMat""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_MAT_ELEM_PTR" "', argument " "1"" of type '" "CvMat""'");
} else {
CvMat * temp = reinterpret_cast< CvMat * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_MAT_ELEM_PTR" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_MAT_ELEM_PTR" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = (void *)CV_MAT_ELEM_PTR(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAT_ELEM_PTR_FAST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CV_MAT_ELEM_PTR_FAST",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvMat, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "1"" of type '" "CvMat""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "1"" of type '" "CvMat""'");
} else {
CvMat * temp = reinterpret_cast< CvMat * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
result = (void *)CV_MAT_ELEM_PTR_FAST(arg1,arg2,arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_VAL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
CvSparseNode *arg2 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_NODE_VAL",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NODE_VAL" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NODE_VAL" "', argument " "2"" of type '" "CvSparseNode *""'");
}
arg2 = reinterpret_cast< CvSparseNode * >(argp2);
result = (void *)CV_NODE_VAL(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IDX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
CvSparseNode *arg2 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_NODE_IDX",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NODE_IDX" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NODE_IDX" "', argument " "2"" of type '" "CvSparseNode *""'");
}
arg2 = reinterpret_cast< CvSparseNode * >(argp2);
result = (int *)CV_NODE_IDX(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_SUBDIV2D_NEXT_EDGE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
PyObject * obj0 = 0 ;
CvQuadEdge2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CV_SUBDIV2D_NEXT_EDGE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
result = (CvQuadEdge2D *)CV_SUBDIV2D_NEXT_EDGE(arg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_SWAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CV_SWAP",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_SWAP" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_SWAP" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_SWAP" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
CV_SWAP(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IMIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_IMIN",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_IMIN" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_IMIN" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int)CV_IMIN(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IMAX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_IMAX",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_IMAX" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_IMAX" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int)CV_IMAX(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IABS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IABS",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_IABS" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_IABS(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_CMP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_CMP",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_CMP" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_CMP" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
CV_CMP(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_SIGN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CV_SIGN",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_SIGN" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
CV_SIGN(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInvSqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvInvSqrt",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvInvSqrt" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
cvInvSqrt(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSqrt",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSqrt" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
cvSqrt(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_IMAGE_HDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_IMAGE_HDR",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
result = (int)CV_IS_IMAGE_HDR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_IMAGE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_IMAGE",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
result = (int)CV_IS_IMAGE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAKETYPE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_MAKETYPE",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_MAKETYPE" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_MAKETYPE" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
result = (int)CV_MAKETYPE(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_8UC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_8UC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_8UC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_8UC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_8SC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_8SC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_8SC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_8SC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_16UC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_16UC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_16UC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_16UC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_16SC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_16SC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_16SC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_16SC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_32SC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_32SC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_32SC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_32SC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_32FC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_32FC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_32FC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_32FC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_64FC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_64FC",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_64FC" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_64FC(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAT_CN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_MAT_CN",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_MAT_CN" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_MAT_CN(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAT_DEPTH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_MAT_DEPTH",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_MAT_DEPTH" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_MAT_DEPTH(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_MAT_TYPE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_MAT_TYPE",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_MAT_TYPE" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_MAT_TYPE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MAT_CONT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MAT_CONT",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_IS_MAT_CONT" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_IS_MAT_CONT(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_TEMP_MAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_TEMP_MAT",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_IS_TEMP_MAT" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_IS_TEMP_MAT(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MAT_HDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MAT_HDR",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MAT_HDR" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MAT_HDR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MAT",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MAT" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MAT(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MASK_ARR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MASK_ARR",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MASK_ARR" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MASK_ARR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ARE_TYPES_EQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_ARE_TYPES_EQ",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_ARE_TYPES_EQ" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_ARE_TYPES_EQ" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
result = (int)CV_ARE_TYPES_EQ(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ARE_CNS_EQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_ARE_CNS_EQ",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_ARE_CNS_EQ" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_ARE_CNS_EQ" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
result = (int)CV_ARE_CNS_EQ(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ARE_DEPTHS_EQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_ARE_DEPTHS_EQ",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_ARE_DEPTHS_EQ" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_ARE_DEPTHS_EQ" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
result = (int)CV_ARE_DEPTHS_EQ(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ARE_SIZES_EQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_ARE_SIZES_EQ",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_ARE_SIZES_EQ" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_ARE_SIZES_EQ" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
result = (int)CV_ARE_SIZES_EQ(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MAT_CONST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MAT_CONST",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MAT_CONST" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MAT_CONST(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ELEM_SIZE1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_ELEM_SIZE1",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_ELEM_SIZE1" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_ELEM_SIZE1(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_ELEM_SIZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_ELEM_SIZE",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_ELEM_SIZE" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_ELEM_SIZE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MATND_HDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MATND_HDR",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MATND_HDR" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MATND_HDR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_MATND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_MATND",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_MATND" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_MATND(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SPARSE_MAT_HDR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SPARSE_MAT_HDR",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SPARSE_MAT_HDR" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_SPARSE_MAT_HDR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SPARSE_MAT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SPARSE_MAT",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SPARSE_MAT" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int)CV_IS_SPARSE_MAT(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_HIST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_HIST",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_HIST" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (int)CV_IS_HIST(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_UNIFORM_HIST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_UNIFORM_HIST",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_UNIFORM_HIST" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (int)CV_IS_UNIFORM_HIST(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SPARSE_HIST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SPARSE_HIST",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SPARSE_HIST" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (int)CV_IS_SPARSE_HIST(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_HIST_HAS_RANGES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_HIST_HAS_RANGES",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_HIST_HAS_RANGES" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (int)CV_HIST_HAS_RANGES(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_STORAGE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_STORAGE",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_STORAGE" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (int)CV_IS_STORAGE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SET_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int res1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SET_ELEM",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SET_ELEM" "', argument " "1"" of type '" "void *""'");
}
result = (int)CV_IS_SET_ELEM(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SET(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SET",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int)CV_IS_SET(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_SEQ_ELTYPE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_SEQ_ELTYPE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_SEQ_ELTYPE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_SEQ_KIND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_SEQ_KIND",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_SEQ_KIND(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_INDEX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_INDEX",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_INDEX(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CURVE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CURVE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CURVE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CLOSED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CLOSED",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CLOSED(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CONVEX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CONVEX",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CONVEX(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_HOLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_HOLE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_HOLE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_SIMPLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_SIMPLE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_SIMPLE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_POINT_SET(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_POINT_SET",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_POINT_SET(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_POINT_SUBSET(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_POINT_SUBSET",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_POINT_SUBSET(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_POLYLINE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_POLYLINE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_POLYLINE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_POLYGON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_POLYGON",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_POLYGON(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CHAIN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CHAIN",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CHAIN(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CONTOUR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CONTOUR",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CONTOUR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_CHAIN_CONTOUR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_CHAIN_CONTOUR",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_CHAIN_CONTOUR(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SEQ_POLYGON_TREE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SEQ_POLYGON_TREE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SEQ_POLYGON_TREE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_GRAPH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_GRAPH",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_GRAPH(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_GRAPH_ORIENTED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_GRAPH_ORIENTED",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_GRAPH_ORIENTED(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_SUBDIV2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_SUBDIV2D",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_IS_SUBDIV2D(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_WRITE_SEQ_ELEM_VAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
CvSeqWriter arg2 ;
int res1 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_WRITE_SEQ_ELEM_VAR",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "1"" of type '" "void *""'");
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqWriter, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "2"" of type '" "CvSeqWriter""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "2"" of type '" "CvSeqWriter""'");
} else {
CvSeqWriter * temp = reinterpret_cast< CvSeqWriter * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_WRITE_SEQ_ELEM_VAR(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_WRITE_SEQ_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvSeqWriter arg2 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_WRITE_SEQ_ELEM",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqWriter, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_WRITE_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqWriter""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_WRITE_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqWriter""'");
} else {
CvSeqWriter * temp = reinterpret_cast< CvSeqWriter * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_WRITE_SEQ_ELEM(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NEXT_SEQ_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
CvSeqReader arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_NEXT_SEQ_ELEM",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NEXT_SEQ_ELEM" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NEXT_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_NEXT_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_NEXT_SEQ_ELEM(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_PREV_SEQ_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
CvSeqReader arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_PREV_SEQ_ELEM",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_PREV_SEQ_ELEM" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_PREV_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_PREV_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_PREV_SEQ_ELEM(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_READ_SEQ_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvSeqReader arg2 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_READ_SEQ_ELEM",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_READ_SEQ_ELEM(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_REV_READ_SEQ_ELEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvSeqReader arg2 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_REV_READ_SEQ_ELEM",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_REV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_REV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
CV_REV_READ_SEQ_ELEM(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_CURRENT_POINT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_CURRENT_POINT",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_CURRENT_POINT" "', argument " "1"" of type '" "CvSeqReader""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_CURRENT_POINT" "', argument " "1"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = CV_CURRENT_POINT(arg1);
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_PREV_POINT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_PREV_POINT",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_PREV_POINT" "', argument " "1"" of type '" "CvSeqReader""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_PREV_POINT" "', argument " "1"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
result = CV_PREV_POINT(arg1);
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_READ_EDGE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvPoint arg2 ;
CvSeqReader arg3 ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CV_READ_EDGE",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSeqReader, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CV_READ_EDGE" "', argument " "3"" of type '" "CvSeqReader""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_EDGE" "', argument " "3"" of type '" "CvSeqReader""'");
} else {
CvSeqReader * temp = reinterpret_cast< CvSeqReader * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
CV_READ_EDGE(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NEXT_GRAPH_EDGE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CV_NEXT_GRAPH_EDGE",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NEXT_GRAPH_EDGE" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NEXT_GRAPH_EDGE" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
result = (CvGraphEdge *)CV_NEXT_GRAPH_EDGE(arg1,arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_TYPE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_TYPE",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_TYPE" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_TYPE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_INT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_INT",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_INT" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_INT(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_REAL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_REAL",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_REAL" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_REAL(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_STRING(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_STRING",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_STRING" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_STRING(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_SEQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_SEQ",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_SEQ" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_SEQ(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_MAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_MAP",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_MAP" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_MAP(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_COLLECTION(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_COLLECTION",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_COLLECTION" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_COLLECTION(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_FLOW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_FLOW",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_FLOW" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_FLOW(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_EMPTY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_EMPTY",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_EMPTY" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_EMPTY(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_IS_USER(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_IS_USER",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_IS_USER" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_IS_USER(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_HAS_NAME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_HAS_NAME",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_NODE_HAS_NAME" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
result = (int)CV_NODE_HAS_NAME(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NODE_SEQ_IS_SIMPLE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NODE_SEQ_IS_SIMPLE",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int)CV_NODE_SEQ_IS_SIMPLE(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReshapeND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
int *arg5 = (int *) 0 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvReshapeND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReshapeND" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReshapeND" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvReshapeND" "', argument " "5"" of type '" "int *""'");
}
arg5 = reinterpret_cast< int * >(argp5);
cvReshapeND(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvConvert",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
cvConvert(arg1,arg2);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAXPY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvAXPY",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvAXPY" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
cvAXPY(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvAbs",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
cvAbs(arg1,arg2);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMatMulAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMatMulAdd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
cvMatMulAdd(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMatMul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMatMul",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
cvMatMul(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetGraphVtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetGraphVtx",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetGraphVtx" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
cvGetGraphVtx(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphVtxIdx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphVtxIdx",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphVtxIdx" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
result = (int)cvGraphVtxIdx(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphEdgeIdx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphEdge *arg2 = (CvGraphEdge *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphEdgeIdx",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphEdgeIdx" "', argument " "2"" of type '" "CvGraphEdge *""'");
}
arg2 = reinterpret_cast< CvGraphEdge * >(argp2);
result = (int)cvGraphEdgeIdx(arg1,arg2);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphGetVtxCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGraphGetVtxCount",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int)cvGraphGetVtxCount(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphGetEdgeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGraphGetEdgeCount",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int)cvGraphGetEdgeCount(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_GRAPH_VERTEX_VISITED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_GRAPH_VERTEX_VISITED",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_GRAPH_VERTEX_VISITED" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
result = (int)CV_IS_GRAPH_VERTEX_VISITED(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_GRAPH_EDGE_VISITED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_GRAPH_EDGE_VISITED",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_GRAPH_EDGE_VISITED" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
result = (int)CV_IS_GRAPH_EDGE_VISITED(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_RGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
int arg3 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CV_RGB",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CV_RGB" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_RGB" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_RGB" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
result = CV_RGB(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_NEXT_LINE_POINT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CV_NEXT_LINE_POINT",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvLineIterator, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NEXT_LINE_POINT" "', argument " "1"" of type '" "CvLineIterator""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_NEXT_LINE_POINT" "', argument " "1"" of type '" "CvLineIterator""'");
} else {
CvLineIterator * temp = reinterpret_cast< CvLineIterator * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
CV_NEXT_LINE_POINT(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_INIT_3X3_DELTAS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 = (double *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CV_INIT_3X3_DELTAS",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_INIT_3X3_DELTAS" "', argument " "1"" of type '" "double *""'");
}
arg1 = reinterpret_cast< double * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_INIT_3X3_DELTAS" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_INIT_3X3_DELTAS" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
CV_INIT_3X3_DELTAS(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CV_IS_HAAR_CLASSIFIER(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int res1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CV_IS_HAAR_CLASSIFIER",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_HAAR_CLASSIFIER" "', argument " "1"" of type '" "void *""'");
}
result = (int)CV_IS_HAAR_CLASSIFIER(arg1);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcBackProject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvHistogram *arg3 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCalcBackProject",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcBackProject" "', argument " "1"" of type '" "IplImage *""'");
}
arg1 = reinterpret_cast< IplImage * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcBackProject" "', argument " "3"" of type '" "CvHistogram *""'");
}
arg3 = reinterpret_cast< CvHistogram * >(argp3);
cvCalcBackProject(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcBackProjectPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSize arg3 ;
CvHistogram *arg4 = (CvHistogram *) 0 ;
int arg5 ;
double arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
void *argp3 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvCalcBackProjectPatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcBackProjectPatch" "', argument " "1"" of type '" "IplImage *""'");
}
arg1 = reinterpret_cast< IplImage * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcBackProjectPatch" "', argument " "3"" of type '" "CvSize""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcBackProjectPatch" "', argument " "3"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcBackProjectPatch" "', argument " "4"" of type '" "CvHistogram *""'");
}
arg4 = reinterpret_cast< CvHistogram * >(argp4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcBackProjectPatch" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcBackProjectPatch" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
cvCalcBackProjectPatch(arg1,arg2,arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN int Swig_var_icvDepthToType_set(PyObject *) {
SWIG_Error(SWIG_AttributeError,"Variable icvDepthToType is read-only.");
return 1;
}
SWIGINTERN PyObject *Swig_var_icvDepthToType_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(icvDepthToType), SWIGTYPE_p_signed_char, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_cvCreateImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize arg1 ;
int arg2 ;
int arg3 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCreateImage",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateImage" "', argument " "1"" of type '" "CvSize""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCreateImage" "', argument " "1"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateImage" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateImage" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMat *)cvCreateImageMat(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCloneImage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCloneImage" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (CvMat *)cvCloneImageMat(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv32suf_i_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_i_set" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_i_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->i = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv32suf_i_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_i_get" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
result = (int) ((arg1)->i);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_u_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
unsigned int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv32suf_u_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_u_set" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_u_set" "', argument " "2"" of type '" "unsigned int""'");
}
arg2 = static_cast< unsigned int >(val2);
if (arg1) (arg1)->u = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_u_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned int result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv32suf_u_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_u_get" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
result = (unsigned int) ((arg1)->u);
resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv32suf_f_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_f_set" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_f_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->f = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv32suf_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv32suf_f_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_f_get" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
result = (float) ((arg1)->f);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Cv32suf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Cv32suf")) SWIG_fail;
{
try {
result = (Cv32suf *)new Cv32suf();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cv32suf, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Cv32suf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv32suf *arg1 = (Cv32suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Cv32suf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv32suf, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cv32suf" "', argument " "1"" of type '" "Cv32suf *""'");
}
arg1 = reinterpret_cast< Cv32suf * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Cv32suf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Cv32suf, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_Cv64suf_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
int64 arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int64 val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv64suf_i_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_i_set" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv64suf_i_set" "', argument " "2"" of type '" "int64""'");
}
arg2 = static_cast< int64 >(val2);
if (arg1) (arg1)->i = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv64suf_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int64 result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv64suf_i_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_i_get" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
result = (int64) ((arg1)->i);
resultobj = SWIG_From_long_SS_long(static_cast< int64 >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv64suf_u_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
uint64 arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
uint64 val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv64suf_u_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_u_set" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv64suf_u_set" "', argument " "2"" of type '" "uint64""'");
}
arg2 = static_cast< uint64 >(val2);
if (arg1) (arg1)->u = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv64suf_u_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uint64 result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv64suf_u_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_u_get" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
result = (uint64) ((arg1)->u);
resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< uint64 >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv64suf_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:Cv64suf_f_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_f_set" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv64suf_f_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->f = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Cv64suf_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:Cv64suf_f_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_f_get" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
result = (double) ((arg1)->f);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_Cv64suf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_Cv64suf")) SWIG_fail;
{
try {
result = (Cv64suf *)new Cv64suf();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cv64suf, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_Cv64suf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv64suf *arg1 = (Cv64suf *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_Cv64suf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Cv64suf, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cv64suf" "', argument " "1"" of type '" "Cv64suf *""'");
}
arg1 = reinterpret_cast< Cv64suf * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *Cv64suf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_Cv64suf, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvRound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRound",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRound" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = (int)cvRound(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvFloor",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvFloor" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = (int)cvFloor(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCeil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvCeil",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCeil" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = (int)cvCeil(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvIsNaN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvIsNaN",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvIsNaN" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = (int)cvIsNaN(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvIsInf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvIsInf",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvIsInf" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = (int)cvIsInf(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRNG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int64 arg1 ;
int64 val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvRNG result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRNG",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRNG" "', argument " "1"" of type '" "int64""'");
}
arg1 = static_cast< int64 >(val1);
{
try {
result = (CvRNG)cvRNG(arg1);
}
catch (...)
{
SWIG_fail;
}
}
{
CvRNG_Wrapper * wrapper = new CvRNG_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvRNG_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRNG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG result;
if (!PyArg_ParseTuple(args,(char *)":cvRNG")) SWIG_fail;
{
try {
result = (CvRNG)cvRNG();
}
catch (...)
{
SWIG_fail;
}
}
{
CvRNG_Wrapper * wrapper = new CvRNG_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvRNG_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRNG(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[2];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_cvRNG__SWIG_1(self, args);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_long_SS_long(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvRNG__SWIG_0(self, args);
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvRNG'.\n"
" Possible C/C++ prototypes are:\n"
" cvRNG(int64)\n"
" cvRNG()\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRandInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG *arg1 = (CvRNG *) 0 ;
void *vptr1 ;
CvRNG_Wrapper *wrapper1 ;
PyObject * obj0 = 0 ;
unsigned int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRandInt",&obj0)) SWIG_fail;
{
if(SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Python object to C value");
return NULL;
}
wrapper1 = (CvRNG_Wrapper *) vptr1;
arg1 = wrapper1->ptr();
}
{
try {
result = (unsigned int)cvRandInt(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRandReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG *arg1 = (CvRNG *) 0 ;
void *vptr1 ;
CvRNG_Wrapper *wrapper1 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRandReal",&obj0)) SWIG_fail;
{
if(SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Python object to C value");
return NULL;
}
wrapper1 = (CvRNG_Wrapper *) vptr1;
arg1 = wrapper1->ptr();
}
{
try {
result = (double)cvRandReal(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_ID_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_ID_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_ID_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->ID = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_ID_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_ID_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->ID);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_nChannels_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_nChannels_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_nChannels_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nChannels = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_nChannels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_nChannels_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->nChannels);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_depth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_depth_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_depth_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->depth = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_depth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_depth_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->depth);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_dataOrder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_dataOrder_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_dataOrder_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->dataOrder = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_dataOrder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_dataOrder_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->dataOrder);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_origin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_origin_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_origin_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->origin = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_origin_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->origin);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_align_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_align_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_align_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->align = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_align_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_align_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->align);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_width_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_width_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_width_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->width);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_height_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_height_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_height_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->height);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_roi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
_IplROI *arg2 = (_IplROI *) 0 ;
IplImage header1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_roi_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__IplROI, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IplImage_roi_set" "', argument " "2"" of type '" "_IplROI *""'");
}
arg2 = reinterpret_cast< _IplROI * >(argp2);
if (arg1) (arg1)->roi = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_roi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
_IplROI *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_roi_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (_IplROI *) ((arg1)->roi);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplROI, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_imageSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_imageSize_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_imageSize_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->imageSize = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_imageSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_imageSize_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->imageSize);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_widthStep_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
int arg2 ;
IplImage header1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage_widthStep_set",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_widthStep_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->widthStep = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage_widthStep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage_widthStep_get",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
result = (int) ((arg1)->widthStep);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_IplImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_IplImage",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
try {
delete_IplImage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___and____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___and__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_SA___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___iand____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___iand__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_SA__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___add__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sa___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___iadd__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sa__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___mul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sm___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___imul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___imul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sm__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___sub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Ss___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___isub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Ss__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___div____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___div__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sd___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___idiv____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___idiv__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sd__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___or____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___or__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_So___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ior____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ior__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_So__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___xor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___xor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sx___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ixor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ixor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sx__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___add__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Sa___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___add__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___add____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___add____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___iadd__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Sa__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___iadd__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___iadd____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___iadd____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___iadd__'.\n"
" Possible C/C++ prototypes are:\n"
" operator +=(IplImage *,CvArr *)\n"
" operator +=(IplImage *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___xor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___xor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Sx___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___xor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___xor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___xor____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___ixor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ixor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Sx__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ixor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___ixor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___ixor____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___ixor__'.\n"
" Possible C/C++ prototypes are:\n"
" operator ^=(IplImage *,CvArr *)\n"
" operator ^=(IplImage *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___sub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Ss___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___sub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___sub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___sub____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___isub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_Ss__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___isub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___isub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___isub____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___isub__'.\n"
" Possible C/C++ prototypes are:\n"
" operator -=(IplImage *,CvArr *)\n"
" operator -=(IplImage *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___or____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___or__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_So___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___or__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___or____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___or____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___ior____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ior__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_So__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ior__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___ior____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___ior____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___ior__'.\n"
" Possible C/C++ prototypes are:\n"
" operator |=(IplImage *,CvArr *)\n"
" operator |=(IplImage *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___and____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___and__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_SA___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___and__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___and____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___and____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___iand____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___iand__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage_operator_SA__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___iand__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___iand____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___iand____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___iand__'.\n"
" Possible C/C++ prototypes are:\n"
" operator &=(IplImage *,CvArr *)\n"
" operator &=(IplImage *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ge____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ge__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sg__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ge____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ge__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ge__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sg__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ge__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___ge____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___ge____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___eq__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Se__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___eq__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___eq__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Se__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___eq__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___eq____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___eq____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___le____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___le__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sl__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___le____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___le__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___le__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sl__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___le__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___le____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___le____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ne__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_SN__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ne__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ne__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_SN__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ne__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___ne____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___ne____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___lt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___lt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sl___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___lt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___lt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___lt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sl___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___lt__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___lt____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___lt____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___gt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___gt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage_operator_Sg___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___gt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___gt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___gt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sg___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___gt__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___gt____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___gt____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___mul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___mul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sm___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___mul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___mul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___mul____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___imul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___imul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___imul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sm__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___imul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___imul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___imul____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___imul__'.\n"
" Possible C/C++ prototypes are:\n"
" operator *=(IplImage *,CvArr *)\n"
" operator *=(IplImage *,double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___div____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___div__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___div__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sd___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___div__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___div____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___div____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___idiv____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___idiv__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___idiv__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage_operator_Sd__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___idiv__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___idiv____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___idiv____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___idiv__'.\n"
" Possible C/C++ prototypes are:\n"
" operator /=(IplImage *,CvArr *)\n"
" operator /=(IplImage *,double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___radd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___radd__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage___radd____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rsub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rsub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage___rsub____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rdiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rdiv__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage___rdiv__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rmul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rmul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (IplImage *)IplImage___rmul____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___radd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___radd__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage___radd____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___radd____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___radd__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___radd__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___radd____SWIG_2(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___radd__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___radd____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___radd____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___radd____SWIG_2(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___rsub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rsub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage___rsub____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rsub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rsub__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rsub__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rsub____SWIG_2(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rsub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___rsub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___rsub____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___rsub____SWIG_2(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___rmul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rmul__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rmul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rmul____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rmul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___rmul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___rmul____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___ror____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ror__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage___ror____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ror____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___ror__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ror__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___ror____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___ror__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___ror____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___ror____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___rand____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rand__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage___rand____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rand____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rand__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rand__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rand____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rand__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___rand____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___rand____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___rxor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
CvScalar arg2 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rxor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (IplImage *)IplImage___rxor____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rxor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rxor__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rxor__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rxor____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rxor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_IplImage___rxor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___rxor____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_IplImage___req__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___req__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___req__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___req__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rgt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rgt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rgt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rgt__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rge__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rge__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rge__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rlt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rlt__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rlt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rlt__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rle__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rle__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rle__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rle__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___rne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___rne__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rne__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___rne__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___pow__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
double arg2 ;
IplImage header1 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___pow__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___pow__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (IplImage *)IplImage___pow__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:IplImage___str__",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
try {
result = (char *)IplImage___str__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
double arg3 ;
IplImage header1 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:IplImage___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IplImage___setitem__" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
IplImage___setitem____SWIG_0(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvPoint arg3 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:IplImage___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
{
arg3 = PyObject_to_CvPoint(obj2);
}
{
try {
IplImage___setitem____SWIG_1(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvPoint2D32f arg3 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:IplImage___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
{
arg3 = PyObject_to_CvPoint2D32f(obj2);
}
{
try {
IplImage___setitem____SWIG_2(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvScalar arg3 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:IplImage___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
try {
IplImage___setitem____SWIG_3(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
IplImage header1 ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:IplImage___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
IplImage___setitem____SWIG_4(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___setitem__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_IplImage___setitem____SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvPoint2D32f, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_IplImage___setitem____SWIG_2(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
_v = CvScalar_Check( argv[2] );
}
if (_v) {
return _wrap_IplImage___setitem____SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
void *ptr;
if (argv[2] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[2]) || PyTuple_Check(argv[2])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_IplImage___setitem____SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_IplImage___setitem____SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IplImage___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" __setitem__(IplImage *,PyObject *,double)\n"
" __setitem__(IplImage *,PyObject *,CvPoint)\n"
" __setitem__(IplImage *,PyObject *,CvPoint2D32f)\n"
" __setitem__(IplImage *,PyObject *,CvScalar)\n"
" __setitem__(IplImage *,PyObject *,CvArr *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_IplImage___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplImage___getitem__",&obj0,&obj1)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
arg2 = obj1;
{
try {
result = (PyObject *)IplImage___getitem__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *IplImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p__IplImage, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_IplROI_coi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplROI_coi_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_coi_set" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_coi_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->coi = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_coi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplROI_coi_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_coi_get" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
result = (int) ((arg1)->coi);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_xOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplROI_xOffset_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_xOffset_set" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_xOffset_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->xOffset = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_xOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplROI_xOffset_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_xOffset_get" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
result = (int) ((arg1)->xOffset);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_yOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplROI_yOffset_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_yOffset_set" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_yOffset_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->yOffset = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_yOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplROI_yOffset_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_yOffset_get" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
result = (int) ((arg1)->yOffset);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplROI_width_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_width_set" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_width_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplROI_width_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_width_get" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
result = (int) ((arg1)->width);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplROI_height_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_height_set" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_height_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplROI_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplROI_height_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_height_get" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
result = (int) ((arg1)->height);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_IplROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_IplROI")) SWIG_fail;
{
try {
result = (IplROI *)new IplROI();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplROI, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_IplROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI *arg1 = (IplROI *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_IplROI",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplROI, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplROI" "', argument " "1"" of type '" "IplROI *""'");
}
arg1 = reinterpret_cast< IplROI * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *IplROI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p__IplROI, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nCols_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_nCols_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nCols_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nCols_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nCols = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nCols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_nCols_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nCols_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int) ((arg1)->nCols);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nRows_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_nRows_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nRows_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nRows_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nRows = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nRows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_nRows_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nRows_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int) ((arg1)->nRows);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_anchorX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_anchorX_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorX_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_anchorX_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->anchorX = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_anchorX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_anchorX_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorX_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int) ((arg1)->anchorX);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_anchorY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_anchorY_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorY_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_anchorY_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->anchorY = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_anchorY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_anchorY_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorY_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int) ((arg1)->anchorY);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_values_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_values_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_values_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IplConvKernel_values_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->values = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_values_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_values_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_values_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int *) ((arg1)->values);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nShiftR_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernel_nShiftR_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nShiftR_set" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nShiftR_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nShiftR = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernel_nShiftR_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernel_nShiftR_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nShiftR_get" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
result = (int) ((arg1)->nShiftR);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_IplConvKernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernel *arg1 = (IplConvKernel *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_IplConvKernel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernel, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplConvKernel" "', argument " "1"" of type '" "IplConvKernel *""'");
}
arg1 = reinterpret_cast< IplConvKernel * >(argp1);
{
try {
delete_IplConvKernel(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *IplConvKernel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p__IplConvKernel, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_nCols_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernelFP_nCols_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nCols_set" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_nCols_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nCols = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_nCols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernelFP_nCols_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nCols_get" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
result = (int) ((arg1)->nCols);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_nRows_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernelFP_nRows_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nRows_set" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_nRows_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nRows = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_nRows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernelFP_nRows_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nRows_get" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
result = (int) ((arg1)->nRows);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_anchorX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernelFP_anchorX_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorX_set" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_anchorX_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->anchorX = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_anchorX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernelFP_anchorX_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorX_get" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
result = (int) ((arg1)->anchorX);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_anchorY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernelFP_anchorY_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorY_set" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_anchorY_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->anchorY = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_anchorY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernelFP_anchorY_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorY_get" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
result = (int) ((arg1)->anchorY);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_values_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:IplConvKernelFP_values_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_values_set" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IplConvKernelFP_values_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->values = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_IplConvKernelFP_values_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:IplConvKernelFP_values_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_values_get" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
result = (float *) ((arg1)->values);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_IplConvKernelFP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_IplConvKernelFP")) SWIG_fail;
{
try {
result = (IplConvKernelFP *)new IplConvKernelFP();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplConvKernelFP, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_IplConvKernelFP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplConvKernelFP *arg1 = (IplConvKernelFP *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_IplConvKernelFP",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__IplConvKernelFP, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplConvKernelFP" "', argument " "1"" of type '" "IplConvKernelFP *""'");
}
arg1 = reinterpret_cast< IplConvKernelFP * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *IplConvKernelFP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p__IplConvKernelFP, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMat_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_type_set" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_type_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_step_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_step_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_step_set" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_step_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->step = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_step_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_step_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int) ((arg1)->step);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_refcount_set" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_refcount_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_refcount_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int *) ((arg1)->refcount);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_hdr_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_hdr_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_hdr_refcount_set" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_hdr_refcount_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->hdr_refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_hdr_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_hdr_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_hdr_refcount_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (int) ((arg1)->hdr_refcount);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
result = (CvMat_data *)& ((arg1)->data);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat_data, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMat" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
delete_CvMat(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_depth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_depth_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_depth_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_depth_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_nChannels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_nChannels_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_nChannels_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_nChannels_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_dataOrder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_dataOrder_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_dataOrder_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_dataOrder_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_origin_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_origin_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_origin_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_width_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_width_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_width_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_height_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_height_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_height_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_imageSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_imageSize_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_imageSize_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_imageSize_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_widthStep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_widthStep_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_widthStep_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_widthStep_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_rows_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_rows_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_rows_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_rows_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_cols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_cols_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_cols_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (int)CvMat_cols_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___and____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___and__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___and__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_SA___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___iand____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___iand__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___iand__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_SA__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___add__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___add__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sa___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___iadd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___iadd__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sa__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___mul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___mul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sm___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___imul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___imul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___imul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sm__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___sub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Ss___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___isub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___isub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Ss__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___div____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___div__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___div__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sd___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___idiv____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___idiv__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___idiv__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sd__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___or____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___or__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___or__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_So___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ior____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ior__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ior__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_So__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___xor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___xor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___xor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sx___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ixor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ixor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ixor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sx__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___add__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___add__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Sa___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___add__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___add____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___add____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___iadd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___iadd__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Sa__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___iadd__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___iadd____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___iadd____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___iadd__'.\n"
" Possible C/C++ prototypes are:\n"
" operator +=(CvMat *,CvArr *)\n"
" operator +=(CvMat *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___xor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___xor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___xor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Sx___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___xor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___xor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___xor____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___ixor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ixor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ixor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Sx__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ixor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___ixor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___ixor____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___ixor__'.\n"
" Possible C/C++ prototypes are:\n"
" operator ^=(CvMat *,CvArr *)\n"
" operator ^=(CvMat *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___sub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___sub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Ss___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___sub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___sub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___sub____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___isub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___isub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_Ss__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___isub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___isub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___isub____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___isub__'.\n"
" Possible C/C++ prototypes are:\n"
" operator -=(CvMat *,CvArr *)\n"
" operator -=(CvMat *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___or____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___or__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___or__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_So___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___or__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___or____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___or____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___ior____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ior__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ior__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_So__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ior__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___ior____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___ior____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___ior__'.\n"
" Possible C/C++ prototypes are:\n"
" operator |=(CvMat *,CvArr *)\n"
" operator |=(CvMat *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___and____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___and__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___and__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_SA___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___and__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___and____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___and____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___iand____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___iand__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___iand__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat_operator_SA__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___iand__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___iand____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___iand____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___iand__'.\n"
" Possible C/C++ prototypes are:\n"
" operator &=(CvMat *,CvArr *)\n"
" operator &=(CvMat *,CvScalar)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ge____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ge__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ge__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sg__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ge____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ge__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ge__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ge__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sg__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ge__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___ge____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___ge____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___eq__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Se__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___eq__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___eq__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___eq__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Se__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___eq__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___eq____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___eq____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___le____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___le__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___le__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sl__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___le____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___le__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___le__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___le__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sl__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___le__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___le____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___le____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ne__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_SN__Se___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ne__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ne__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_SN__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ne__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___ne____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___ne____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___lt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___lt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___lt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sl___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___lt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___lt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___lt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___lt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sl___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___lt__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___lt____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___lt____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___gt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___gt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___gt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat_operator_Sg___SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___gt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___gt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___gt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___gt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sg___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___gt__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___gt____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___gt____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___mul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___mul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___mul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sm___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___mul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___mul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___mul____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___imul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___imul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___imul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___imul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sm__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___imul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___imul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___imul____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___imul__'.\n"
" Possible C/C++ prototypes are:\n"
" operator *=(CvMat *,CvArr *)\n"
" operator *=(CvMat *,double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___div____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___div__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___div__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___div__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sd___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___div__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___div____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___div____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___idiv____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___idiv__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___idiv__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___idiv__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat_operator_Sd__Se___SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___idiv__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___idiv____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___idiv____SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___idiv__'.\n"
" Possible C/C++ prototypes are:\n"
" operator /=(CvMat *,CvArr *)\n"
" operator /=(CvMat *,double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___radd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___radd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat___radd____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rsub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rsub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat___rsub____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rdiv____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rdiv__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rdiv__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat___rdiv____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rmul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rmul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rmul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (CvMat *)CvMat___rmul____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___radd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___radd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat___radd____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___radd____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___radd__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___radd__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___radd____SWIG_2(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___radd__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___radd____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___radd____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___radd____SWIG_2(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___rsub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rsub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat___rsub____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rsub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rsub__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rsub__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rsub____SWIG_2(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rsub__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___rsub____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___rsub____SWIG_1(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___rsub____SWIG_2(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___rmul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rmul__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rmul__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rmul__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rmul____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rmul__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___rmul____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___rmul____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___ror____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ror__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ror__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat___ror____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ror____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___ror__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___ror__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ror__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___ror____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___ror__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___ror____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___ror____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___rand____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rand__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rand__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat___rand____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rand____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rand__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rand__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rand__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rand____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rand__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___rand____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___rand____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___rxor____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvScalar arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rxor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rxor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
try {
result = (CvMat *)CvMat___rxor____SWIG_0(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rxor____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rxor__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rxor__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rxor__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rxor____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rxor__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
_v = CvScalar_Check( argv[1] );
}
if (_v) {
return _wrap_CvMat___rxor____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___rxor____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___req__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___req__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___req__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___req__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___req__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rgt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rgt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rgt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rgt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rgt__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rge__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rge__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rge__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rge__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rlt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rlt__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rlt__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rlt__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rlt__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rle__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rle__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rle__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rle__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rle__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rne__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rne__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rne__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rne__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rdiv____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___rdiv__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___rdiv__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rdiv__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___rdiv____SWIG_1(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___rdiv__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
void *ptr;
if (argv[1] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[1]) || PyTuple_Check(argv[1])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___rdiv____SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___rdiv____SWIG_1(self, args);
}
}
}
fail:
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
SWIGINTERN PyObject *_wrap_CvMat___pow__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___pow__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___pow__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___pow__" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = (CvMat *)CvMat___pow__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___str__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (char *)CvMat___str__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
double arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMat___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___setitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMat___setitem__" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
CvMat___setitem____SWIG_0(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvPoint arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMat___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___setitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
arg3 = PyObject_to_CvPoint(obj2);
}
{
try {
CvMat___setitem____SWIG_1(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvPoint2D32f arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMat___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___setitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
arg3 = PyObject_to_CvPoint2D32f(obj2);
}
{
try {
CvMat___setitem____SWIG_2(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvScalar arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMat___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___setitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
try {
CvMat___setitem____SWIG_3(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMat___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___setitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
CvMat___setitem____SWIG_4(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___setitem__(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMat___setitem____SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvPoint2D32f, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMat___setitem____SWIG_2(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
_v = CvScalar_Check( argv[2] );
}
if (_v) {
return _wrap_CvMat___setitem____SWIG_3(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
void *ptr;
if (argv[2] == Py_None) {
_v = 1;
}
if(PyList_Check(argv[2]) || PyTuple_Check(argv[2])) {
_v = 1;
}
else if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_CvMat, 0) != -1){
_v = 1;
}
else {
_v = 0;
PyErr_Clear();
}
}
if (_v) {
return _wrap_CvMat___setitem____SWIG_4(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
_v = (argv[1] != 0);
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMat___setitem____SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMat___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
" __setitem__(CvMat *,PyObject *,double)\n"
" __setitem__(CvMat *,PyObject *,CvPoint)\n"
" __setitem__(CvMat *,PyObject *,CvPoint2D32f)\n"
" __setitem__(CvMat *,PyObject *,CvScalar)\n"
" __setitem__(CvMat *,PyObject *,CvArr *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___getitem__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
try {
result = (PyObject *)CvMat___getitem__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat___invert__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat___invert__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat___invert__" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (CvMat *)CvMat___invert__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_imageData_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
PyObject *arg2 = (PyObject *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_imageData_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_imageData_set" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
arg2 = obj1;
{
try {
CvMat_imageData_set(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_imageData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_imageData_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_imageData_get" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (PyObject *)CvMat_imageData_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = result;
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMat, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMat_data_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
uchar *arg2 = (uchar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_data_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_ptr_set" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_ptr_set" "', argument " "2"" of type '" "uchar *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_ptr_get" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
result = (uchar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
short *arg2 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_data_s_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_s_set" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_s_set" "', argument " "2"" of type '" "short *""'");
}
arg2 = reinterpret_cast< short * >(argp2);
if (arg1) (arg1)->s = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_s_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_s_get" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
result = (short *) ((arg1)->s);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_data_i_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_i_set" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_i_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->i = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_i_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_i_get" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
result = (int *) ((arg1)->i);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_fl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_data_fl_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_fl_set" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_fl_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->fl = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_fl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_fl_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_fl_get" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
result = (float *) ((arg1)->fl);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_db_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
double *arg2 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMat_data_db_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_db_set" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_db_set" "', argument " "2"" of type '" "double *""'");
}
arg2 = reinterpret_cast< double * >(argp2);
if (arg1) (arg1)->db = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMat_data_db_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMat_data_db_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_db_get" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
result = (double *) ((arg1)->db);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMat_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMat_data")) SWIG_fail;
{
try {
result = (CvMat_data *)new CvMat_data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat_data, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMat_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat_data *arg1 = (CvMat_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMat_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat_data, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMat_data" "', argument " "1"" of type '" "CvMat_data *""'");
}
arg1 = reinterpret_cast< CvMat_data * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMat_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMat_data, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
void *arg4 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMat result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvMat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMat" "', argument " "4"" of type '" "void *""'");
}
{
try {
result = cvMat(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvMat(static_cast< const CvMat& >(result))), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMat",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvMat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = cvMat(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvMat(static_cast< const CvMat& >(result))), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMat(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvMat__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvMat__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvMat'.\n"
" Possible C/C++ prototypes are:\n"
" cvMat(int,int,int,void *)\n"
" cvMat(int,int,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvmGet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvmGet",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvmGet" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvmGet" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvmGet" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvmGet((CvMat const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvmSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
int arg3 ;
double arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvmSet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvmSet" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvmSet" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvmSet" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvmSet" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
{
try {
cvmSet(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCvToIplDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvCvToIplDepth",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCvToIplDepth" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (int)cvCvToIplDepth(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_type_set" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_type_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dims_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_dims_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dims_set" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_dims_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->dims = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dims_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_dims_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dims_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (int) ((arg1)->dims);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_refcount_set" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_refcount_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_refcount_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (int *) ((arg1)->refcount);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_hdr_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_hdr_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_hdr_refcount_set" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_hdr_refcount_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->hdr_refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_hdr_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_hdr_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_hdr_refcount_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (int) ((arg1)->hdr_refcount);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dim_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatND_dim *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_dim_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (CvMatND_dim *)(CvMatND_dim *) ((arg1)->dim);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_dim, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatND_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_get" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
result = (CvMatND_data *)& ((arg1)->data);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_data, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMatND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMatND",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
{
try {
delete_CvMatND(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMatND_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMatND, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMatND_dim_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *arg1 = (CvMatND_dim *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_dim_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_size_set" "', argument " "1"" of type '" "CvMatND_dim *""'");
}
arg1 = reinterpret_cast< CvMatND_dim * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_dim_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dim_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *arg1 = (CvMatND_dim *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_dim_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_size_get" "', argument " "1"" of type '" "CvMatND_dim *""'");
}
arg1 = reinterpret_cast< CvMatND_dim * >(argp1);
result = (int) ((arg1)->size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dim_step_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *arg1 = (CvMatND_dim *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_dim_step_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_step_set" "', argument " "1"" of type '" "CvMatND_dim *""'");
}
arg1 = reinterpret_cast< CvMatND_dim * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_dim_step_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->step = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_dim_step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *arg1 = (CvMatND_dim *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_dim_step_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_step_get" "', argument " "1"" of type '" "CvMatND_dim *""'");
}
arg1 = reinterpret_cast< CvMatND_dim * >(argp1);
result = (int) ((arg1)->step);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatND_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMatND_dim")) SWIG_fail;
{
try {
result = (CvMatND_dim *)new CvMatND_dim();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_dim, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMatND_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_dim *arg1 = (CvMatND_dim *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMatND_dim",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_dim, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND_dim" "', argument " "1"" of type '" "CvMatND_dim *""'");
}
arg1 = reinterpret_cast< CvMatND_dim * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMatND_dim_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMatND_dim, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMatND_data_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
uchar *arg2 = (uchar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_data_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_ptr_set" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_ptr_set" "', argument " "2"" of type '" "uchar *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_ptr_get" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
result = (uchar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_fl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_data_fl_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_fl_set" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_fl_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->fl = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_fl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_fl_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_fl_get" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
result = (float *) ((arg1)->fl);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_db_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
double *arg2 = (double *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_data_db_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_db_set" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_db_set" "', argument " "2"" of type '" "double *""'");
}
arg2 = reinterpret_cast< double * >(argp2);
if (arg1) (arg1)->db = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_db_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_db_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_db_get" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
result = (double *) ((arg1)->db);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_data_i_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_i_set" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_i_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->i = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_i_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_i_get" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
result = (int *) ((arg1)->i);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
short *arg2 = (short *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatND_data_s_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_s_set" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_s_set" "', argument " "2"" of type '" "short *""'");
}
arg2 = reinterpret_cast< short * >(argp2);
if (arg1) (arg1)->s = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatND_data_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
short *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatND_data_s_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_s_get" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
result = (short *) ((arg1)->s);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatND_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMatND_data")) SWIG_fail;
{
try {
result = (CvMatND_data *)new CvMatND_data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_data, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMatND_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND_data *arg1 = (CvMatND_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMatND_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND_data, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND_data" "', argument " "1"" of type '" "CvMatND_data *""'");
}
arg1 = reinterpret_cast< CvMatND_data * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMatND_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMatND_data, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSparseMat_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_type_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_type_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_dims_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_dims_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_dims_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_dims_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->dims = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_dims_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_dims_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_dims_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->dims);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_refcount_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMat_refcount_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_refcount_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int *) ((arg1)->refcount);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hdr_refcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_hdr_refcount_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hdr_refcount_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_hdr_refcount_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->hdr_refcount = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hdr_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_hdr_refcount_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hdr_refcount_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->hdr_refcount);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_heap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
CvSet *arg2 = (CvSet *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_heap_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_heap_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg2 = (CvSet *)ptr2;
}
if (arg1) (arg1)->heap = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_heap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSet *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_heap_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_heap_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (CvSet *) ((arg1)->heap);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hashtable_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void **arg2 = (void **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
void *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_hashtable_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashtable_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer2 = (void *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->hashtable = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hashtable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_hashtable_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashtable_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (void **) ((arg1)->hashtable);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hashsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_hashsize_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashsize_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_hashsize_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->hashsize = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_hashsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_hashsize_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashsize_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->hashsize);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_valoffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_valoffset_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_valoffset_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_valoffset_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->valoffset = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_valoffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_valoffset_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_valoffset_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->valoffset);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_idxoffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_idxoffset_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_idxoffset_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_idxoffset_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->idxoffset = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_idxoffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_idxoffset_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_idxoffset_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int) ((arg1)->idxoffset);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
int *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMat_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_size_set" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMat_size_set" "', argument " "2"" of type '" "int [32]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)32; ++ii) arg1->size[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""size""' of type '""int [32]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMat_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMat_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_size_get" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
result = (int *)(int *) ((arg1)->size);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSparseMat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseMat" "', argument " "1"" of type '" "CvSparseMat *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
{
try {
delete_CvSparseMat(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSparseMat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSparseMat, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSparseNode_hashval_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *arg1 = (CvSparseNode *) 0 ;
unsigned int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseNode_hashval_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_hashval_set" "', argument " "1"" of type '" "CvSparseNode *""'");
}
arg1 = reinterpret_cast< CvSparseNode * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseNode_hashval_set" "', argument " "2"" of type '" "unsigned int""'");
}
arg2 = static_cast< unsigned int >(val2);
if (arg1) (arg1)->hashval = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseNode_hashval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *arg1 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseNode_hashval_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_hashval_get" "', argument " "1"" of type '" "CvSparseNode *""'");
}
arg1 = reinterpret_cast< CvSparseNode * >(argp1);
result = (unsigned int) ((arg1)->hashval);
resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseNode_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *arg1 = (CvSparseNode *) 0 ;
CvSparseNode *arg2 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseNode_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_next_set" "', argument " "1"" of type '" "CvSparseNode *""'");
}
arg1 = reinterpret_cast< CvSparseNode * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseNode_next_set" "', argument " "2"" of type '" "CvSparseNode *""'");
}
arg2 = reinterpret_cast< CvSparseNode * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseNode_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *arg1 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSparseNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseNode_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_next_get" "', argument " "1"" of type '" "CvSparseNode *""'");
}
arg1 = reinterpret_cast< CvSparseNode * >(argp1);
result = (CvSparseNode *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSparseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSparseNode")) SWIG_fail;
{
try {
result = (CvSparseNode *)new CvSparseNode();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSparseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseNode *arg1 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSparseNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseNode" "', argument " "1"" of type '" "CvSparseNode *""'");
}
arg1 = reinterpret_cast< CvSparseNode * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSparseNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSparseNode, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_mat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
CvSparseMat *arg2 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMatIterator_mat_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_mat_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMatIterator_mat_set" "', argument " "2"" of type '" "CvSparseMat *""'");
}
arg2 = reinterpret_cast< CvSparseMat * >(argp2);
if (arg1) (arg1)->mat = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_mat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSparseMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMatIterator_mat_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_mat_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
result = (CvSparseMat *) ((arg1)->mat);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_node_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
CvSparseNode *arg2 = (CvSparseNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMatIterator_node_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_node_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMatIterator_node_set" "', argument " "2"" of type '" "CvSparseNode *""'");
}
arg2 = reinterpret_cast< CvSparseNode * >(argp2);
if (arg1) (arg1)->node = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_node_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSparseNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMatIterator_node_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_node_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
result = (CvSparseNode *) ((arg1)->node);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_curidx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSparseMatIterator_curidx_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_curidx_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMatIterator_curidx_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->curidx = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSparseMatIterator_curidx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSparseMatIterator_curidx_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_curidx_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
result = (int) ((arg1)->curidx);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSparseMatIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSparseMatIterator")) SWIG_fail;
{
try {
result = (CvSparseMatIterator *)new CvSparseMatIterator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMatIterator, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSparseMatIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSparseMatIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseMatIterator" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSparseMatIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSparseMatIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHistogram_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHistogram_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_type_set" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHistogram_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHistogram_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_type_get" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_bins_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHistogram_bins_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_bins_set" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (arg1) (arg1)->bins = arg2;
resultobj = SWIG_Py_Void();
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_bins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvArr *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHistogram_bins_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_bins_get" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (CvArr *) ((arg1)->bins);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_thresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
float (*arg2)[2] ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHistogram_thresh_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh_set" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_2__float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHistogram_thresh_set" "', argument " "2"" of type '" "float [32][2]""'");
}
arg2 = reinterpret_cast< float (*)[2] >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)32; ++ii) {
if (arg2[ii]) {
size_t jj = 0;
for (; jj < (size_t)2; ++jj) arg1->thresh[ii][jj] = arg2[ii][jj];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""thresh""' of type '""float [32][2]""'");
}
}
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""thresh""' of type '""float [32][2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_thresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float (*result)[2] = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHistogram_thresh_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh_get" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (float (*)[2])(float (*)[2]) ((arg1)->thresh);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_2__float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_thresh2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
float **arg2 = (float **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
float *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHistogram_thresh2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh2_set" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_float, 1)) == -1){
SWIG_fail;
}
buffer2 = (float *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->thresh2 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_thresh2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHistogram_thresh2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh2_get" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (float **) ((arg1)->thresh2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_mat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
CvMatND *arg2 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHistogram_mat_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_mat_set" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHistogram_mat_set" "', argument " "2"" of type '" "CvMatND *""'");
}
arg2 = reinterpret_cast< CvMatND * >(argp2);
if (arg1) (arg1)->mat = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHistogram_mat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatND *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHistogram_mat_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_mat_get" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
result = (CvMatND *)& ((arg1)->mat);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHistogram",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHistogram" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
try {
delete_CvHistogram(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHistogram, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvRect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRect_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_x_set" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_x_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvRect_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_x_get" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
result = (int) ((arg1)->x);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRect_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_y_set" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_y_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvRect_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_y_get" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
result = (int) ((arg1)->y);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRect_width_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_width_set" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_width_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvRect_width_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_width_get" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
result = (int) ((arg1)->width);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvRect_height_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_height_set" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_height_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvRect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvRect_height_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_height_get" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
result = (int) ((arg1)->height);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvRect")) SWIG_fail;
{
try {
result = (CvRect *)new CvRect();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvRect",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRect" "', argument " "1"" of type '" "CvRect *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvRect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvRect, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvRect result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvRect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRect" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRect" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRect" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvRect" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = cvRect(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvRect(static_cast< const CvRect& >(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRectToROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect arg1 ;
int arg2 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
IplROI result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvRectToROI",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRectToROI" "', argument " "1"" of type '" "CvRect""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvRectToROI" "', argument " "1"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRectToROI" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvRectToROI(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new IplROI(static_cast< const IplROI& >(result))), SWIGTYPE_p__IplROI, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvROIToRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplROI arg1 ;
void *argp1 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect result;
if (!PyArg_ParseTuple(args,(char *)"O:cvROIToRect",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__IplROI, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvROIToRect" "', argument " "1"" of type '" "IplROI""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvROIToRect" "', argument " "1"" of type '" "IplROI""'");
} else {
IplROI * temp = reinterpret_cast< IplROI * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
try {
result = cvROIToRect(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvRect(static_cast< const CvRect& >(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTermCriteria_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_type_set" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTermCriteria_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_type_get" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
result = (int) ((arg1)->type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_max_iter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTermCriteria_max_iter_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_max_iter_set" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_max_iter_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->max_iter = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_max_iter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTermCriteria_max_iter_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_max_iter_get" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
result = (int) ((arg1)->max_iter);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_epsilon_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTermCriteria_epsilon_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_epsilon_set" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_epsilon_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->epsilon = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTermCriteria_epsilon_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTermCriteria_epsilon_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_epsilon_get" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
result = (double) ((arg1)->epsilon);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTermCriteria(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTermCriteria")) SWIG_fail;
{
try {
result = (CvTermCriteria *)new CvTermCriteria();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTermCriteria(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria *arg1 = (CvTermCriteria *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTermCriteria",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTermCriteria" "', argument " "1"" of type '" "CvTermCriteria *""'");
}
arg1 = reinterpret_cast< CvTermCriteria * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTermCriteria_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTermCriteria, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvTermCriteria(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
double arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvTermCriteria result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvTermCriteria",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvTermCriteria" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvTermCriteria" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvTermCriteria" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = cvTermCriteria(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvTermCriteria(static_cast< const CvTermCriteria& >(result))), SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_x_set" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint_x_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_x_get" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
result = (int) ((arg1)->x);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_y_set" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint_y_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_y_get" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
result = (int) ((arg1)->y);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint___str__" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
{
try {
result = (char *)CvPoint___str__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint___repr__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint___repr__" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
{
try {
result = (char *)CvPoint___repr__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPoint")) SWIG_fail;
{
try {
result = (CvPoint *)new CvPoint();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint *arg1 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPoint",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint" "', argument " "1"" of type '" "CvPoint *""'");
}
arg1 = reinterpret_cast< CvPoint * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPoint, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvPoint",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPoint" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvPoint(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint2D32f_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_x_set" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D32f_x_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D32f_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_x_get" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
result = (float) ((arg1)->x);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint2D32f_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_y_set" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D32f_y_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D32f_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_y_get" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
result = (float) ((arg1)->y);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D32f___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f___str__" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
{
try {
result = (char *)CvPoint2D32f___str__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D32f___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D32f___repr__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f___repr__" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
{
try {
result = (char *)CvPoint2D32f___repr__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPoint2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPoint2D32f")) SWIG_fail;
{
try {
result = (CvPoint2D32f *)new CvPoint2D32f();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPoint2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPoint2D32f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint2D32f" "', argument " "1"" of type '" "CvPoint2D32f *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPoint2D32f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPoint2D32f, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvPoint2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint2D32f result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvPoint2D32f",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint2D32f" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPoint2D32f" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = cvPoint2D32f(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint2D32f(static_cast< const CvPoint2D32f& >(result))), SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPointTo32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
PyObject * obj0 = 0 ;
CvPoint2D32f result;
if (!PyArg_ParseTuple(args,(char *)"O:cvPointTo32f",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
try {
result = cvPointTo32f(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint2D32f(static_cast< const CvPoint2D32f& >(result))), SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPointFrom32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f arg1 ;
PyObject * obj0 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"O:cvPointFrom32f",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint2D32f(obj0);
}
{
try {
result = cvPointFrom32f(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D32f_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_x_set" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_x_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D32f_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_x_get" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
result = (float) ((arg1)->x);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D32f_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_y_set" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_y_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D32f_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_y_get" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
result = (float) ((arg1)->y);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D32f_z_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_z_set" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_z_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->z = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D32f_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D32f_z_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_z_get" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
result = (float) ((arg1)->z);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPoint3D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPoint3D32f")) SWIG_fail;
{
try {
result = (CvPoint3D32f *)new CvPoint3D32f();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPoint3D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPoint3D32f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint3D32f" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPoint3D32f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPoint3D32f, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvPoint3D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double arg3 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvPoint3D32f result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvPoint3D32f",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint3D32f" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPoint3D32f" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPoint3D32f" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = cvPoint3D32f(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint3D32f(static_cast< const CvPoint3D32f& >(result))), SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D64f_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *arg1 = (CvPoint2D64f *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint2D64f_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_x_set" "', argument " "1"" of type '" "CvPoint2D64f *""'");
}
arg1 = reinterpret_cast< CvPoint2D64f * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D64f_x_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D64f_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *arg1 = (CvPoint2D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D64f_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_x_get" "', argument " "1"" of type '" "CvPoint2D64f *""'");
}
arg1 = reinterpret_cast< CvPoint2D64f * >(argp1);
result = (double) ((arg1)->x);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D64f_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *arg1 = (CvPoint2D64f *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint2D64f_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_y_set" "', argument " "1"" of type '" "CvPoint2D64f *""'");
}
arg1 = reinterpret_cast< CvPoint2D64f * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D64f_y_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint2D64f_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *arg1 = (CvPoint2D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint2D64f_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_y_get" "', argument " "1"" of type '" "CvPoint2D64f *""'");
}
arg1 = reinterpret_cast< CvPoint2D64f * >(argp1);
result = (double) ((arg1)->y);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPoint2D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPoint2D64f")) SWIG_fail;
{
try {
result = (CvPoint2D64f *)new CvPoint2D64f();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPoint2D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D64f *arg1 = (CvPoint2D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPoint2D64f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint2D64f" "', argument " "1"" of type '" "CvPoint2D64f *""'");
}
arg1 = reinterpret_cast< CvPoint2D64f * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPoint2D64f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPoint2D64f, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvPoint2D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint2D64f result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvPoint2D64f",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint2D64f" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPoint2D64f" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = cvPoint2D64f(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint2D64f(static_cast< const CvPoint2D64f& >(result))), SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D64f_x_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_x_set" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_x_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->x = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D64f_x_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_x_get" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
result = (double) ((arg1)->x);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D64f_y_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_y_set" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_y_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->y = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D64f_y_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_y_get" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
result = (double) ((arg1)->y);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPoint3D64f_z_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_z_set" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_z_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->z = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPoint3D64f_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPoint3D64f_z_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_z_get" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
result = (double) ((arg1)->z);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPoint3D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPoint3D64f")) SWIG_fail;
{
try {
result = (CvPoint3D64f *)new CvPoint3D64f();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPoint3D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D64f *arg1 = (CvPoint3D64f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPoint3D64f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint3D64f" "', argument " "1"" of type '" "CvPoint3D64f *""'");
}
arg1 = reinterpret_cast< CvPoint3D64f * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPoint3D64f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPoint3D64f, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvPoint3D64f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double arg3 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvPoint3D64f result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvPoint3D64f",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint3D64f" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPoint3D64f" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPoint3D64f" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = cvPoint3D64f(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint3D64f(static_cast< const CvPoint3D64f& >(result))), SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *arg1 = (CvSize *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSize_width_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_width_set" "', argument " "1"" of type '" "CvSize *""'");
}
arg1 = reinterpret_cast< CvSize * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize_width_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *arg1 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSize_width_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_width_get" "', argument " "1"" of type '" "CvSize *""'");
}
arg1 = reinterpret_cast< CvSize * >(argp1);
result = (int) ((arg1)->width);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *arg1 = (CvSize *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSize_height_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_height_set" "', argument " "1"" of type '" "CvSize *""'");
}
arg1 = reinterpret_cast< CvSize * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize_height_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *arg1 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSize_height_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_height_get" "', argument " "1"" of type '" "CvSize *""'");
}
arg1 = reinterpret_cast< CvSize * >(argp1);
result = (int) ((arg1)->height);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSize")) SWIG_fail;
{
try {
result = (CvSize *)new CvSize();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize *arg1 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSize",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSize" "', argument " "1"" of type '" "CvSize *""'");
}
arg1 = reinterpret_cast< CvSize * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSize, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSize",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSize" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSize" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvSize(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize2D32f_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *arg1 = (CvSize2D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSize2D32f_width_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_width_set" "', argument " "1"" of type '" "CvSize2D32f *""'");
}
arg1 = reinterpret_cast< CvSize2D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize2D32f_width_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->width = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize2D32f_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *arg1 = (CvSize2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSize2D32f_width_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_width_get" "', argument " "1"" of type '" "CvSize2D32f *""'");
}
arg1 = reinterpret_cast< CvSize2D32f * >(argp1);
result = (float) ((arg1)->width);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize2D32f_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *arg1 = (CvSize2D32f *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSize2D32f_height_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_height_set" "', argument " "1"" of type '" "CvSize2D32f *""'");
}
arg1 = reinterpret_cast< CvSize2D32f * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize2D32f_height_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->height = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSize2D32f_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *arg1 = (CvSize2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSize2D32f_height_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_height_get" "', argument " "1"" of type '" "CvSize2D32f *""'");
}
arg1 = reinterpret_cast< CvSize2D32f * >(argp1);
result = (float) ((arg1)->height);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSize2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSize2D32f")) SWIG_fail;
{
try {
result = (CvSize2D32f *)new CvSize2D32f();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSize2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize2D32f *arg1 = (CvSize2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSize2D32f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSize2D32f" "', argument " "1"" of type '" "CvSize2D32f *""'");
}
arg1 = reinterpret_cast< CvSize2D32f * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSize2D32f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSize2D32f, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvSize2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSize2D32f result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSize2D32f",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSize2D32f" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSize2D32f" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = cvSize2D32f(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize2D32f(static_cast< const CvSize2D32f& >(result))), SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_center_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvBox2D_center_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_center_set" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBox2D_center_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->center = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_center_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvBox2D_center_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_center_get" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
result = (CvPoint2D32f *)& ((arg1)->center);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
CvSize2D32f *arg2 = (CvSize2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvBox2D_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_size_set" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSize2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBox2D_size_set" "', argument " "2"" of type '" "CvSize2D32f *""'");
}
arg2 = reinterpret_cast< CvSize2D32f * >(argp2);
if (arg1) (arg1)->size = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvBox2D_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_size_get" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
result = (CvSize2D32f *)& ((arg1)->size);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_angle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvBox2D_angle_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_angle_set" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBox2D_angle_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->angle = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBox2D_angle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBox2D_angle_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_angle_get" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
result = (float) ((arg1)->angle);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBox2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvBox2D")) SWIG_fail;
{
try {
result = (CvBox2D *)new CvBox2D();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBox2D, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvBox2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D *arg1 = (CvBox2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvBox2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBox2D, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBox2D" "', argument " "1"" of type '" "CvBox2D *""'");
}
arg1 = reinterpret_cast< CvBox2D * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvBox2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvBox2D, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvLineIterator_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
uchar *arg2 = (uchar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_ptr_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLineIterator_ptr_set" "', argument " "2"" of type '" "uchar *""'");
}
arg2 = reinterpret_cast< uchar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_ptr_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (uchar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_err_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_err_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_err_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->err = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_err_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_err_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (int) ((arg1)->err);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_plus_delta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_plus_delta_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_delta_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_plus_delta_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->plus_delta = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_plus_delta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_plus_delta_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_delta_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (int) ((arg1)->plus_delta);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_minus_delta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_minus_delta_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_delta_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_minus_delta_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->minus_delta = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_minus_delta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_minus_delta_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_delta_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (int) ((arg1)->minus_delta);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_plus_step_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_plus_step_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_step_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_plus_step_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->plus_step = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_plus_step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_plus_step_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_step_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (int) ((arg1)->plus_step);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_minus_step_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLineIterator_minus_step_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_step_set" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_minus_step_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->minus_step = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLineIterator_minus_step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLineIterator_minus_step_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_step_get" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
result = (int) ((arg1)->minus_step);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLineIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvLineIterator")) SWIG_fail;
{
try {
result = (CvLineIterator *)new CvLineIterator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLineIterator, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvLineIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLineIterator *arg1 = (CvLineIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvLineIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLineIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvLineIterator" "', argument " "1"" of type '" "CvLineIterator *""'");
}
arg1 = reinterpret_cast< CvLineIterator * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvLineIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvLineIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSlice_start_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *arg1 = (CvSlice *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSlice_start_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSlice, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_start_index_set" "', argument " "1"" of type '" "CvSlice *""'");
}
arg1 = reinterpret_cast< CvSlice * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSlice_start_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->start_index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSlice_start_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *arg1 = (CvSlice *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSlice_start_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSlice, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_start_index_get" "', argument " "1"" of type '" "CvSlice *""'");
}
arg1 = reinterpret_cast< CvSlice * >(argp1);
result = (int) ((arg1)->start_index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSlice_end_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *arg1 = (CvSlice *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSlice_end_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSlice, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_end_index_set" "', argument " "1"" of type '" "CvSlice *""'");
}
arg1 = reinterpret_cast< CvSlice * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSlice_end_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->end_index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSlice_end_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *arg1 = (CvSlice *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSlice_end_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSlice, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_end_index_get" "', argument " "1"" of type '" "CvSlice *""'");
}
arg1 = reinterpret_cast< CvSlice * >(argp1);
result = (int) ((arg1)->end_index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSlice")) SWIG_fail;
{
try {
result = (CvSlice *)new CvSlice();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSlice, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice *arg1 = (CvSlice *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSlice",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSlice, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSlice" "', argument " "1"" of type '" "CvSlice *""'");
}
arg1 = reinterpret_cast< CvSlice * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSlice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSlice, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSlice result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSlice",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSlice" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSlice" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvSlice(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSlice(static_cast< const CvSlice& >(result))), SWIGTYPE_p_CvSlice, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
double *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvScalar_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar_val_set" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvScalar_val_set" "', argument " "2"" of type '" "double [4]""'");
}
arg2 = reinterpret_cast< double * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4; ++ii) arg1->val[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [4]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvScalar_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar_val_get" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
result = (double *)(double *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvScalar___str__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___str__" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
{
try {
result = (char *)CvScalar___str__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvScalar___repr__",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___repr__" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
{
try {
result = (char *)CvScalar___repr__(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvScalar___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___getitem__" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvScalar___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (double)CvScalar___getitem__(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvScalar___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
int arg2 ;
double arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvScalar___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___setitem__" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvScalar___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvScalar___setitem__" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
CvScalar___setitem__(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvScalar")) SWIG_fail;
{
try {
result = (CvScalar *)new CvScalar();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvScalar, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvScalar",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvScalar" "', argument " "1"" of type '" "CvScalar *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvScalar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvScalar, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvScalar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double arg3 ;
double arg4 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvScalar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvScalar" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvScalar" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvScalar" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
{
try {
result = cvScalar(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double arg3 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvScalar",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvScalar" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvScalar" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = cvScalar(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalar__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvScalar",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvScalar" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
result = cvScalar(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalar__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O:cvScalar",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = cvScalar(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalar(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvScalar__SWIG_3(self, args);
}
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvScalar__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvScalar__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_double(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_double(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_cvScalar__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvScalar'.\n"
" Possible C/C++ prototypes are:\n"
" cvScalar(double,double,double,double)\n"
" cvScalar(double,double,double)\n"
" cvScalar(double,double)\n"
" cvScalar(double)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRealScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRealScalar",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRealScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = cvRealScalar(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalarAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O:cvScalarAll",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalarAll" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
{
try {
result = cvScalarAll(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemBlock_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *arg1 = (CvMemBlock *) 0 ;
CvMemBlock *arg2 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemBlock_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_prev_set" "', argument " "1"" of type '" "CvMemBlock *""'");
}
arg1 = reinterpret_cast< CvMemBlock * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemBlock_prev_set" "', argument " "2"" of type '" "CvMemBlock *""'");
}
arg2 = reinterpret_cast< CvMemBlock * >(argp2);
if (arg1) (arg1)->prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemBlock_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *arg1 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemBlock_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_prev_get" "', argument " "1"" of type '" "CvMemBlock *""'");
}
arg1 = reinterpret_cast< CvMemBlock * >(argp1);
result = (CvMemBlock *) ((arg1)->prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemBlock_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *arg1 = (CvMemBlock *) 0 ;
CvMemBlock *arg2 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemBlock_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_next_set" "', argument " "1"" of type '" "CvMemBlock *""'");
}
arg1 = reinterpret_cast< CvMemBlock * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemBlock_next_set" "', argument " "2"" of type '" "CvMemBlock *""'");
}
arg2 = reinterpret_cast< CvMemBlock * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemBlock_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *arg1 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemBlock_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_next_get" "', argument " "1"" of type '" "CvMemBlock *""'");
}
arg1 = reinterpret_cast< CvMemBlock * >(argp1);
result = (CvMemBlock *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMemBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMemBlock")) SWIG_fail;
{
try {
result = (CvMemBlock *)new CvMemBlock();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMemBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemBlock *arg1 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMemBlock",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemBlock" "', argument " "1"" of type '" "CvMemBlock *""'");
}
arg1 = reinterpret_cast< CvMemBlock * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMemBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMemBlock, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMemStorage_signature_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_signature_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_signature_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_signature_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->signature = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_signature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_signature_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_signature_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (int) ((arg1)->signature);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_bottom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
CvMemBlock *arg2 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_bottom_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_bottom_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStorage_bottom_set" "', argument " "2"" of type '" "CvMemBlock *""'");
}
arg2 = reinterpret_cast< CvMemBlock * >(argp2);
if (arg1) (arg1)->bottom = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_bottom_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_bottom_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (CvMemBlock *) ((arg1)->bottom);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_top_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
CvMemBlock *arg2 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_top_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_top_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStorage_top_set" "', argument " "2"" of type '" "CvMemBlock *""'");
}
arg2 = reinterpret_cast< CvMemBlock * >(argp2);
if (arg1) (arg1)->top = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_top_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_top_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (CvMemBlock *) ((arg1)->top);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_parent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_parent_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_parent_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStorage_parent_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->parent = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_parent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_parent_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_parent_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (CvMemStorage *) ((arg1)->parent);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_block_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_block_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_block_size_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_block_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->block_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_block_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_block_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_block_size_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (int) ((arg1)->block_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_free_space_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStorage_free_space_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_free_space_set" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_free_space_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->free_space = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStorage_free_space_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStorage_free_space_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_free_space_get" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
result = (int) ((arg1)->free_space);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMemStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMemStorage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemStorage" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
{
try {
delete_CvMemStorage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMemStorage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMemStorage, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMemStoragePos_top_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ;
CvMemBlock *arg2 = (CvMemBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStoragePos_top_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_top_set" "', argument " "1"" of type '" "CvMemStoragePos *""'");
}
arg1 = reinterpret_cast< CvMemStoragePos * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStoragePos_top_set" "', argument " "2"" of type '" "CvMemBlock *""'");
}
arg2 = reinterpret_cast< CvMemBlock * >(argp2);
if (arg1) (arg1)->top = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStoragePos_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStoragePos_top_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_top_get" "', argument " "1"" of type '" "CvMemStoragePos *""'");
}
arg1 = reinterpret_cast< CvMemStoragePos * >(argp1);
result = (CvMemBlock *) ((arg1)->top);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStoragePos_free_space_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMemStoragePos_free_space_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_free_space_set" "', argument " "1"" of type '" "CvMemStoragePos *""'");
}
arg1 = reinterpret_cast< CvMemStoragePos * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStoragePos_free_space_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->free_space = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMemStoragePos_free_space_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMemStoragePos_free_space_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_free_space_get" "', argument " "1"" of type '" "CvMemStoragePos *""'");
}
arg1 = reinterpret_cast< CvMemStoragePos * >(argp1);
result = (int) ((arg1)->free_space);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMemStoragePos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMemStoragePos")) SWIG_fail;
{
try {
result = (CvMemStoragePos *)new CvMemStoragePos();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStoragePos, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMemStoragePos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMemStoragePos",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStoragePos, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemStoragePos" "', argument " "1"" of type '" "CvMemStoragePos *""'");
}
arg1 = reinterpret_cast< CvMemStoragePos * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMemStoragePos_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMemStoragePos, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqBlock_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_prev_set" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqBlock_prev_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqBlock_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_prev_get" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
result = (CvSeqBlock *) ((arg1)->prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqBlock_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_next_set" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqBlock_next_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqBlock_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_next_get" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
result = (CvSeqBlock *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_start_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqBlock_start_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_start_index_set" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqBlock_start_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->start_index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_start_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqBlock_start_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_start_index_get" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
result = (int) ((arg1)->start_index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqBlock_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_count_set" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqBlock_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqBlock_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_count_get" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
result = (int) ((arg1)->count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqBlock_data_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_data_set" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqBlock_data_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->data = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqBlock_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqBlock_data_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_data_get" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
result = (schar *) ((arg1)->data);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeqBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeqBlock")) SWIG_fail;
{
try {
result = (CvSeqBlock *)new CvSeqBlock();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeqBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqBlock *arg1 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeqBlock",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqBlock" "', argument " "1"" of type '" "CvSeqBlock *""'");
}
arg1 = reinterpret_cast< CvSeqBlock * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeqBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSeqBlock, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_flags_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_flags_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_header_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_header_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_h_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_h_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_h_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_h_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_v_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_v_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_v_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_v_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_total_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_total_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_elem_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_elem_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_block_max_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_block_max_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_ptr_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_ptr_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_delta_elems_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_delta_elems_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_storage_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_storage_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_free_blocks_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_free_blocks_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_first_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_first_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq")) SWIG_fail;
{
try {
result = (CvSeq *)new CvSeq();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSeq, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSetElem_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *arg1 = (CvSetElem *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSetElem_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_flags_set" "', argument " "1"" of type '" "CvSetElem *""'");
}
arg1 = reinterpret_cast< CvSetElem * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSetElem_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSetElem_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *arg1 = (CvSetElem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSetElem_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_flags_get" "', argument " "1"" of type '" "CvSetElem *""'");
}
arg1 = reinterpret_cast< CvSetElem * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSetElem_next_free_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *arg1 = (CvSetElem *) 0 ;
CvSetElem *arg2 = (CvSetElem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSetElem_next_free_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_next_free_set" "', argument " "1"" of type '" "CvSetElem *""'");
}
arg1 = reinterpret_cast< CvSetElem * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSetElem_next_free_set" "', argument " "2"" of type '" "CvSetElem *""'");
}
arg2 = reinterpret_cast< CvSetElem * >(argp2);
if (arg1) (arg1)->next_free = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSetElem_next_free_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *arg1 = (CvSetElem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSetElem_next_free_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_next_free_get" "', argument " "1"" of type '" "CvSetElem *""'");
}
arg1 = reinterpret_cast< CvSetElem * >(argp1);
result = (CvSetElem *) ((arg1)->next_free);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSetElem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSetElem")) SWIG_fail;
{
try {
result = (CvSetElem *)new CvSetElem();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSetElem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSetElem *arg1 = (CvSetElem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSetElem",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSetElem" "', argument " "1"" of type '" "CvSetElem *""'");
}
arg1 = reinterpret_cast< CvSetElem * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSetElem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSetElem, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSet_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_flags_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_flags_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_header_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_header_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_h_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_h_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_h_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_h_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_v_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_v_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_v_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_v_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_total_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_total_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_elem_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_elem_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_block_max_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_block_max_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_ptr_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_ptr_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_delta_elems_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_delta_elems_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_storage_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_storage_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_free_blocks_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_free_blocks_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_first_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_first_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_free_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSetElem *arg2 = (CvSetElem *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_free_elems_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'");
}
arg2 = reinterpret_cast< CvSetElem * >(argp2);
if (arg1) (arg1)->free_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_free_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_free_elems_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (CvSetElem *) ((arg1)->free_elems);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_active_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSet_active_count_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_active_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->active_count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSet_active_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSet_active_count_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
result = (int) ((arg1)->active_count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSet")) SWIG_fail;
{
try {
result = (CvSet *)new CvSet();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSet",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSet, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphEdge_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_flags_set" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphEdge_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphEdge_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_flags_get" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphEdge_weight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_weight_set" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphEdge_weight_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->weight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphEdge_weight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_weight_get" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
result = (float) ((arg1)->weight);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
CvGraphEdge **arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphEdge_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_next_set" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphEdge_next_set" "', argument " "2"" of type '" "CvGraphEdge *[2]""'");
}
arg2 = reinterpret_cast< CvGraphEdge ** >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2; ++ii) arg1->next[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""next""' of type '""CvGraphEdge *[2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphEdge **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphEdge_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_next_get" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
result = (CvGraphEdge **)(CvGraphEdge **) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_vtx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
CvGraphVtx **arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphEdge_vtx_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_vtx_set" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphEdge_vtx_set" "', argument " "2"" of type '" "CvGraphVtx *[2]""'");
}
arg2 = reinterpret_cast< CvGraphVtx ** >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2; ++ii) arg1->vtx[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""vtx""' of type '""CvGraphVtx *[2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphEdge_vtx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphVtx **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphEdge_vtx_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_vtx_get" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
result = (CvGraphVtx **)(CvGraphVtx **) ((arg1)->vtx);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvGraphVtx, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvGraphEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvGraphEdge")) SWIG_fail;
{
try {
result = (CvGraphEdge *)new CvGraphEdge();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvGraphEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphEdge *arg1 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvGraphEdge",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphEdge" "', argument " "1"" of type '" "CvGraphEdge *""'");
}
arg1 = reinterpret_cast< CvGraphEdge * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvGraphEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvGraphEdge, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvGraphVtx_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphVtx_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_flags_set" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphVtx_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphVtx_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_flags_get" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
CvGraphEdge *arg2 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphVtx_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_first_set" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx_first_set" "', argument " "2"" of type '" "CvGraphEdge *""'");
}
arg2 = reinterpret_cast< CvGraphEdge * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphVtx_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_first_get" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
result = (CvGraphEdge *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvGraphVtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvGraphVtx")) SWIG_fail;
{
try {
result = (CvGraphVtx *)new CvGraphVtx();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvGraphVtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx *arg1 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvGraphVtx",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphVtx" "', argument " "1"" of type '" "CvGraphVtx *""'");
}
arg1 = reinterpret_cast< CvGraphVtx * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvGraphVtx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvGraphVtx, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphVtx2D_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_flags_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphVtx2D_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphVtx2D_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_flags_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
CvGraphEdge *arg2 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphVtx2D_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_first_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx2D_first_set" "', argument " "2"" of type '" "CvGraphEdge *""'");
}
arg2 = reinterpret_cast< CvGraphEdge * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphVtx2D_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_first_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
result = (CvGraphEdge *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphVtx2D_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_ptr_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx2D_ptr_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphVtx2D_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphVtx2D_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_ptr_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
result = (CvPoint2D32f *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvGraphVtx2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvGraphVtx2D")) SWIG_fail;
{
try {
result = (CvGraphVtx2D *)new CvGraphVtx2D();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx2D, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvGraphVtx2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvGraphVtx2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphVtx2D, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphVtx2D" "', argument " "1"" of type '" "CvGraphVtx2D *""'");
}
arg1 = reinterpret_cast< CvGraphVtx2D * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvGraphVtx2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvGraphVtx2D, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvGraph_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_flags_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_flags_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_header_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_header_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_h_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_h_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_h_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_h_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_v_prev_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_v_prev_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_v_next_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_v_next_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_total_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_total_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_elem_size_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_elem_size_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_block_max_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_block_max_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
schar *arg2 = (schar *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_ptr_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_ptr_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_delta_elems_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_delta_elems_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_storage_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_storage_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_free_blocks_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_free_blocks_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_first_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_first_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_free_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSetElem *arg2 = (CvSetElem *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_free_elems_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'");
}
arg2 = reinterpret_cast< CvSetElem * >(argp2);
if (arg1) (arg1)->free_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_free_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_free_elems_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSetElem *) ((arg1)->free_elems);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_active_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_active_count_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_active_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->active_count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_active_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_active_count_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (int) ((arg1)->active_count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_edges_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvSet *arg2 = (CvSet *) 0 ;
void *ptr1 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraph_edges_set",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg2 = (CvSet *)ptr2;
}
if (arg1) (arg1)->edges = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraph_edges_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSet *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraph_edges_get",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
result = (CvSet *) ((arg1)->edges);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvGraph")) SWIG_fail;
{
try {
result = (CvGraph *)new CvGraph();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvGraph",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvGraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvGraph, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvChain_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_flags_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_flags_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_header_size_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_header_size_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_h_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_prev_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_h_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_prev_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_h_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_next_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_h_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_next_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_v_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_prev_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_v_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_prev_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_v_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_next_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_v_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_next_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_total_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_total_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_total_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_total_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_elem_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_elem_size_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_elem_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_elem_size_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_block_max_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_block_max_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_ptr_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_ptr_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_delta_elems_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_delta_elems_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_delta_elems_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_delta_elems_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_storage_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_storage_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_storage_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_storage_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_free_blocks_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_free_blocks_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_free_blocks_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_free_blocks_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_first_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_first_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_origin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChain_origin_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_origin_set" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_origin_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->origin = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChain_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChain_origin_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_origin_get" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
result = (CvPoint *)& ((arg1)->origin);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvChain")) SWIG_fail;
{
try {
result = (CvChain *)new CvChain();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvChain, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvChain",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvChain" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvChain, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvContour_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_flags_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_flags_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_header_size_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_header_size_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_h_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_prev_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_h_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_prev_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_h_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_next_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_h_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_next_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_v_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_prev_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_v_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_prev_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_v_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_next_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_v_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_next_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_total_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_total_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_total_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_total_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_elem_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_elem_size_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_elem_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_elem_size_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_block_max_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_block_max_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_ptr_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_ptr_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_delta_elems_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_delta_elems_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_delta_elems_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_delta_elems_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_storage_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_storage_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_storage_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_storage_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_free_blocks_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_free_blocks_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_free_blocks_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_free_blocks_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_first_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_first_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_rect_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_rect_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_rect_set" "', argument " "2"" of type '" "CvRect *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
if (arg1) (arg1)->rect = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_rect_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_rect_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (CvRect *)& ((arg1)->rect);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_color_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_color_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_color_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->color = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_color_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_color_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int) ((arg1)->color);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_reserved_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
int *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContour_reserved_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_reserved_set" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_reserved_set" "', argument " "2"" of type '" "int [3]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3; ++ii) arg1->reserved[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""reserved""' of type '""int [3]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContour_reserved_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContour_reserved_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_reserved_get" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
result = (int *)(int *) ((arg1)->reserved);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvContour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvContour")) SWIG_fail;
{
try {
result = (CvContour *)new CvContour();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvContour, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvContour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContour *arg1 = (CvContour *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvContour",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContour, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvContour" "', argument " "1"" of type '" "CvContour *""'");
}
arg1 = reinterpret_cast< CvContour * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvContour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvContour, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_header_size_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqWriter_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_header_size_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_seq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_seq_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_seq_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->seq = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_seq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_seq_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_seq_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (CvSeq *) ((arg1)->seq);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_block_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqWriter_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->block = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_block_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (CvSeqBlock *) ((arg1)->block);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_ptr_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqWriter_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_ptr_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_block_min_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_min_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqWriter_block_min_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_min = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_block_min_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_min_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (schar *) ((arg1)->block_min);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqWriter_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_max_set" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqWriter_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqWriter_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqWriter_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_max_get" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeqWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeqWriter")) SWIG_fail;
{
try {
result = (CvSeqWriter *)new CvSeqWriter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqWriter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeqWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeqWriter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqWriter" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeqWriter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSeqWriter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeqReader_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_header_size_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqReader_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_header_size_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_seq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_seq_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_seq_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->seq = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_seq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_seq_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_seq_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (CvSeq *) ((arg1)->seq);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_block_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->block = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_block_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (CvSeqBlock *) ((arg1)->block);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_ptr_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_ptr_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_block_min_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_min_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_block_min_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_min = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_block_min_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_min_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (schar *) ((arg1)->block_min);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_max_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_max_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_delta_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_delta_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_delta_index_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqReader_delta_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_delta_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_delta_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_delta_index_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (int) ((arg1)->delta_index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_prev_elem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeqReader_prev_elem_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_prev_elem_set" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_prev_elem_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->prev_elem = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeqReader_prev_elem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeqReader_prev_elem_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_prev_elem_get" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
result = (schar *) ((arg1)->prev_elem);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeqReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeqReader")) SWIG_fail;
{
try {
result = (CvSeqReader *)new CvSeqReader();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqReader, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeqReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeqReader",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqReader" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeqReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSeqReader, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvAttrList_attr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
char **arg2 = (char **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
char *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvAttrList_attr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_attr_set" "', argument " "1"" of type '" "CvAttrList *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer2 = (char *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->attr = (char const **)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAttrList_attr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvAttrList_attr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_attr_get" "', argument " "1"" of type '" "CvAttrList *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
result = (char **) ((arg1)->attr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAttrList_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
CvAttrList *arg2 = (CvAttrList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvAttrList_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_next_set" "', argument " "1"" of type '" "CvAttrList *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvAttrList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvAttrList_next_set" "', argument " "2"" of type '" "CvAttrList *""'");
}
arg2 = reinterpret_cast< CvAttrList * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAttrList_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvAttrList *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvAttrList_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_next_get" "', argument " "1"" of type '" "CvAttrList *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
result = (CvAttrList *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAttrList, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvAttrList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvAttrList")) SWIG_fail;
{
try {
result = (CvAttrList *)new CvAttrList();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAttrList, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvAttrList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvAttrList",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvAttrList" "', argument " "1"" of type '" "CvAttrList *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvAttrList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvAttrList, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvAttrList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
CvAttrList *arg2 = (CvAttrList *) 0 ;
void *vptr1 ;
char *buffer1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvAttrList result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvAttrList",&obj0,&obj1)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer1 = (char *) vptr1;
arg1=&buffer1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvAttrList" "', argument " "2"" of type '" "CvAttrList *""'");
}
arg2 = reinterpret_cast< CvAttrList * >(argp2);
{
try {
result = cvAttrList((char const **)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvAttrList(static_cast< const CvAttrList& >(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAttrList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
void *vptr1 ;
char *buffer1 ;
PyObject * obj0 = 0 ;
CvAttrList result;
if (!PyArg_ParseTuple(args,(char *)"O:cvAttrList",&obj0)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer1 = (char *) vptr1;
arg1=&buffer1;
}
{
try {
result = cvAttrList((char const **)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvAttrList(static_cast< const CvAttrList& >(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAttrList__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList result;
if (!PyArg_ParseTuple(args,(char *)":cvAttrList")) SWIG_fail;
{
try {
result = cvAttrList();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvAttrList(static_cast< const CvAttrList& >(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAttrList(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_cvAttrList__SWIG_2(self, args);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvAttrList__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_char, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvAttrList, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_cvAttrList__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'cvAttrList'.\n"
" Possible C/C++ prototypes are:\n"
" cvAttrList(char const **,CvAttrList *)\n"
" cvAttrList(char const **)\n"
" cvAttrList()\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvString_len_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *arg1 = (CvString *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvString_len_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_len_set" "', argument " "1"" of type '" "CvString *""'");
}
arg1 = reinterpret_cast< CvString * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvString_len_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->len = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvString_len_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *arg1 = (CvString *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvString_len_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_len_get" "', argument " "1"" of type '" "CvString *""'");
}
arg1 = reinterpret_cast< CvString * >(argp1);
result = (int) ((arg1)->len);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvString_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *arg1 = (CvString *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvString_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_ptr_set" "', argument " "1"" of type '" "CvString *""'");
}
arg1 = reinterpret_cast< CvString * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvString_ptr_set" "', argument " "2"" of type '" "char *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg1->ptr) delete[] arg1->ptr;
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
arg1->ptr = (char *)reinterpret_cast< char* >(memcpy((new char[size]), reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
} else {
arg1->ptr = 0;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvString_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *arg1 = (CvString *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvString_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_ptr_get" "', argument " "1"" of type '" "CvString *""'");
}
arg1 = reinterpret_cast< CvString * >(argp1);
result = (char *) ((arg1)->ptr);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvString")) SWIG_fail;
{
try {
result = (CvString *)new CvString();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvString *arg1 = (CvString *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvString",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvString, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvString" "', argument " "1"" of type '" "CvString *""'");
}
arg1 = reinterpret_cast< CvString * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvString, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_hashval_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
unsigned int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
unsigned int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStringHashNode_hashval_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_hashval_set" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStringHashNode_hashval_set" "', argument " "2"" of type '" "unsigned int""'");
}
arg2 = static_cast< unsigned int >(val2);
if (arg1) (arg1)->hashval = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_hashval_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
unsigned int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStringHashNode_hashval_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_hashval_get" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
result = (unsigned int) ((arg1)->hashval);
resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
CvString *arg2 = (CvString *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStringHashNode_str_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_str_set" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStringHashNode_str_set" "', argument " "2"" of type '" "CvString *""'");
}
arg2 = reinterpret_cast< CvString * >(argp2);
if (arg1) (arg1)->str = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_str_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvString *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStringHashNode_str_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_str_get" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
result = (CvString *)& ((arg1)->str);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
CvStringHashNode *arg2 = (CvStringHashNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStringHashNode_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_next_set" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvStringHashNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStringHashNode_next_set" "', argument " "2"" of type '" "CvStringHashNode *""'");
}
arg2 = reinterpret_cast< CvStringHashNode * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStringHashNode_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvStringHashNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStringHashNode_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_next_get" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
result = (CvStringHashNode *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStringHashNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvStringHashNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvStringHashNode")) SWIG_fail;
{
try {
result = (CvStringHashNode *)new CvStringHashNode();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStringHashNode, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvStringHashNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStringHashNode *arg1 = (CvStringHashNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvStringHashNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStringHashNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStringHashNode" "', argument " "1"" of type '" "CvStringHashNode *""'");
}
arg1 = reinterpret_cast< CvStringHashNode * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvStringHashNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvStringHashNode, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvFileNode_tag_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_tag_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_tag_set" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_tag_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->tag = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_tag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_tag_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_tag_get" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
result = (int) ((arg1)->tag);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
CvTypeInfo *arg2 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_info_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_info_set" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_info_set" "', argument " "2"" of type '" "CvTypeInfo *""'");
}
arg2 = reinterpret_cast< CvTypeInfo * >(argp2);
if (arg1) (arg1)->info = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_info_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_info_get" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
result = (CvTypeInfo *) ((arg1)->info);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvFileNode_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_get" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
result = (CvFileNode_data *)& ((arg1)->data);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode_data, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvFileNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvFileNode")) SWIG_fail;
{
try {
result = (CvFileNode *)new CvFileNode();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvFileNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvFileNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFileNode" "', argument " "1"" of type '" "CvFileNode *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvFileNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvFileNode, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_f_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_data_f_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_f_set" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_data_f_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->f = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_f_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_f_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_f_get" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
result = (double) ((arg1)->f);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_i_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_data_i_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_i_set" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_data_i_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->i = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_i_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_i_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_i_get" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
result = (int) ((arg1)->i);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
CvString *arg2 = (CvString *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_data_str_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_str_set" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvString, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_data_str_set" "', argument " "2"" of type '" "CvString *""'");
}
arg2 = reinterpret_cast< CvString * >(argp2);
if (arg1) (arg1)->str = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_str_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvString *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_str_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_str_get" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
result = (CvString *)& ((arg1)->str);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_seq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_data_seq_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_seq_set" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->seq = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_seq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_seq_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_seq_get" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
result = (CvSeq *) ((arg1)->seq);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_map_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
CvFileNodeHash *arg2 = (CvFileNodeHash *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFileNode_data_map_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_map_set" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGenericHash, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_data_map_set" "', argument " "2"" of type '" "CvFileNodeHash *""'");
}
arg2 = reinterpret_cast< CvFileNodeHash * >(argp2);
if (arg1) (arg1)->map = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFileNode_data_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvFileNodeHash *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFileNode_data_map_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_map_get" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
result = (CvFileNodeHash *) ((arg1)->map);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGenericHash, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvFileNode_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvFileNode_data")) SWIG_fail;
{
try {
result = (CvFileNode_data *)new CvFileNode_data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode_data, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvFileNode_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode_data *arg1 = (CvFileNode_data *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvFileNode_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode_data, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFileNode_data" "', argument " "1"" of type '" "CvFileNode_data *""'");
}
arg1 = reinterpret_cast< CvFileNode_data * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvFileNode_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvFileNode_data, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_flags_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTypeInfo_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_flags_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_header_size_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTypeInfo_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_header_size_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvTypeInfo *arg2 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_prev_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_prev_set" "', argument " "2"" of type '" "CvTypeInfo *""'");
}
arg2 = reinterpret_cast< CvTypeInfo * >(argp2);
if (arg1) (arg1)->prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_prev_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvTypeInfo *) ((arg1)->prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvTypeInfo *arg2 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_next_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_next_set" "', argument " "2"" of type '" "CvTypeInfo *""'");
}
arg2 = reinterpret_cast< CvTypeInfo * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_next_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvTypeInfo *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_type_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_type_name_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_type_name_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_type_name_set" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
arg1->type_name = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
} else {
arg1->type_name = 0;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_type_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_type_name_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_type_name_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (char *) ((arg1)->type_name);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_is_instance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_is_instance_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_is_instance_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_is_instance_set" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
if (arg1) (arg1)->is_instance = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_is_instance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvIsInstanceFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_is_instance_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_is_instance_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvIsInstanceFunc) ((arg1)->is_instance);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__void__int);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_release_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvReleaseFunc arg2 = (CvReleaseFunc) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_release_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_release_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_p_void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_release_set" "', argument " "2"" of type '" "CvReleaseFunc""'");
}
}
if (arg1) (arg1)->release = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_release_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvReleaseFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_release_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_release_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvReleaseFunc) ((arg1)->release);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void__void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_read_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvReadFunc arg2 = (CvReadFunc) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_read_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_read_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_read_set" "', argument " "2"" of type '" "CvReadFunc""'");
}
}
if (arg1) (arg1)->read = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_read_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvReadFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_read_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_read_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvReadFunc) ((arg1)->read);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_write_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvWriteFunc arg2 = (CvWriteFunc) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_write_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_write_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_write_set" "', argument " "2"" of type '" "CvWriteFunc""'");
}
}
if (arg1) (arg1)->write = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_write_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvWriteFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_write_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_write_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvWriteFunc) ((arg1)->write);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_clone_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
CvCloneFunc arg2 = (CvCloneFunc) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTypeInfo_clone_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_clone_set" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_clone_set" "', argument " "2"" of type '" "CvCloneFunc""'");
}
}
if (arg1) (arg1)->clone = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTypeInfo_clone_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvCloneFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTypeInfo_clone_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_clone_get" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
result = (CvCloneFunc) ((arg1)->clone);
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__void__p_void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTypeInfo")) SWIG_fail;
{
try {
result = (CvTypeInfo *)new CvTypeInfo();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTypeInfo",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTypeInfo" "', argument " "1"" of type '" "CvTypeInfo *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypeInfo, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_func_addr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void **arg2 = (void **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
void *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPluginFuncInfo_func_addr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_addr_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer2 = (void *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->func_addr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_func_addr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPluginFuncInfo_func_addr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_addr_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
result = (void **) ((arg1)->func_addr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_default_func_addr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *arg2 = (void *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPluginFuncInfo_default_func_addr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_default_func_addr_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPluginFuncInfo_default_func_addr_set" "', argument " "2"" of type '" "void *""'");
}
if (arg1) (arg1)->default_func_addr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_default_func_addr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPluginFuncInfo_default_func_addr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_default_func_addr_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
result = (void *) ((arg1)->default_func_addr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_func_names_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPluginFuncInfo_func_names_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_names_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPluginFuncInfo_func_names_set" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
arg1->func_names = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
} else {
arg1->func_names = 0;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_func_names_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvPluginFuncInfo_func_names_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_names_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
result = (char *) ((arg1)->func_names);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_search_modules_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPluginFuncInfo_search_modules_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_search_modules_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPluginFuncInfo_search_modules_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->search_modules = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_search_modules_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPluginFuncInfo_search_modules_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_search_modules_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
result = (int) ((arg1)->search_modules);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_loaded_from_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvPluginFuncInfo_loaded_from_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_loaded_from_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPluginFuncInfo_loaded_from_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->loaded_from = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvPluginFuncInfo_loaded_from_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvPluginFuncInfo_loaded_from_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_loaded_from_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
result = (int) ((arg1)->loaded_from);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvPluginFuncInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvPluginFuncInfo")) SWIG_fail;
{
try {
result = (CvPluginFuncInfo *)new CvPluginFuncInfo();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPluginFuncInfo, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvPluginFuncInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvPluginFuncInfo",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPluginFuncInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPluginFuncInfo" "', argument " "1"" of type '" "CvPluginFuncInfo *""'");
}
arg1 = reinterpret_cast< CvPluginFuncInfo * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvPluginFuncInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvPluginFuncInfo, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
CvModuleInfo *arg2 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvModuleInfo_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_next_set" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_next_set" "', argument " "2"" of type '" "CvModuleInfo *""'");
}
arg2 = reinterpret_cast< CvModuleInfo * >(argp2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvModuleInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvModuleInfo_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_next_get" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
result = (CvModuleInfo *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvModuleInfo_name_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_name_set" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_name_set" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
arg1->name = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
} else {
arg1->name = 0;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvModuleInfo_name_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_name_get" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
result = (char *) ((arg1)->name);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvModuleInfo_version_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_version_set" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_version_set" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (arg2) {
size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
arg1->version = (char const *)reinterpret_cast< char* >(memcpy((new char[size]), arg2, sizeof(char)*(size)));
} else {
arg1->version = 0;
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvModuleInfo_version_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_version_get" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
result = (char *) ((arg1)->version);
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_func_tab_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
CvPluginFuncInfo *arg2 = (CvPluginFuncInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvModuleInfo_func_tab_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_func_tab_set" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPluginFuncInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_func_tab_set" "', argument " "2"" of type '" "CvPluginFuncInfo *""'");
}
arg2 = reinterpret_cast< CvPluginFuncInfo * >(argp2);
if (arg1) (arg1)->func_tab = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModuleInfo_func_tab_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPluginFuncInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvModuleInfo_func_tab_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_func_tab_get" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
result = (CvPluginFuncInfo *) ((arg1)->func_tab);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvModuleInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvModuleInfo")) SWIG_fail;
{
try {
result = (CvModuleInfo *)new CvModuleInfo();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvModuleInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvModuleInfo",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvModuleInfo" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvModuleInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvModuleInfo, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvAlloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
size_t arg1 ;
size_t val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvAlloc",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_size_t(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvAlloc" "', argument " "1"" of type '" "size_t""'");
}
arg1 = static_cast< size_t >(val1);
{
try {
result = (void *)cvAlloc(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFree_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int res1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvFree_",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFree_" "', argument " "1"" of type '" "void *""'");
}
{
try {
cvFree_(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvResetImageROI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvResetImageROI",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
try {
cvResetImageROI(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateMatHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCreateMatHeader",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateMatHeader" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateMatHeader" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateMatHeader" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMat *)cvCreateMatHeader(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitMatHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
void *arg5 = (void *) NULL ;
int arg6 = (int) 0x7fffffff ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int res5 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvInitMatHeader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitMatHeader" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvInitMatHeader" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInitMatHeader" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvInitMatHeader" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvInitMatHeader" "', argument " "5"" of type '" "void *""'");
}
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvInitMatHeader" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
result = (CvMat *)cvInitMatHeader(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCreateMat",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateMat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateMat" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateMat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMat *)cvCreateMat(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDecRefData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvDecRefData",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
cvDecRefData(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvIncRefData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvIncRefData",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (int)cvIncRefData(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCloneMat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCloneMat" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (CvMat *)cvCloneMat((CvMat const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSubRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvRect arg3 ;
bool freearg1 = false ;
CvMat *header2 ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetSubRect",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res3 = SWIG_ConvertPtr(obj1, &argp3, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetSubRect" "', argument " "3"" of type '" "CvRect""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvGetSubRect" "', argument " "3"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
{
try {
result = (CvMat *)cvGetSubRect((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
int arg5 = (int) 1 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvGetRows",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetRows" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetRows" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj3) {
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvGetRows" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
result = (CvMat *)cvGetRows((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetRow",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetRow" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMat *)cvGetRow((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetCols",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetCols" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetCols" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (CvMat *)cvGetCols((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetCol",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetCol" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMat *)cvGetCol((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 = (int) 0 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"O|O:cvGetDiag",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetDiag" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = (CvMat *)cvGetDiag((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScalarToRawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvScalar *arg1 = (CvScalar *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvScalarToRawData",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvScalarToRawData" "', argument " "1"" of type '" "CvScalar const *""'");
}
arg1 = reinterpret_cast< CvScalar * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvScalarToRawData" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvScalarToRawData" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvScalarToRawData" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvScalarToRawData((CvScalar const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRawDataToScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int arg2 ;
CvScalar *arg3 = (CvScalar *) 0 ;
int res1 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvRawDataToScalar",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRawDataToScalar" "', argument " "1"" of type '" "void const *""'");
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRawDataToScalar" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRawDataToScalar" "', argument " "3"" of type '" "CvScalar *""'");
}
arg3 = reinterpret_cast< CvScalar * >(argp3);
{
try {
cvRawDataToScalar((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateMatNDHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMatND *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreateMatNDHeader",&obj0,&obj1)) SWIG_fail;
{
int i;
/* get the size of the dimention array */
arg1 = PyList_Size (obj0);
/* allocate the needed memory */
arg2 = (int *)malloc (arg1 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg1; i++) {
PyObject *item = PyList_GetItem (obj0, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateMatNDHeader" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMatND *)cvCreateMatNDHeader(arg1,(int const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateMatND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMatND *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreateMatND",&obj0,&obj1)) SWIG_fail;
{
int i;
/* get the size of the dimention array */
arg1 = PyList_Size (obj0);
/* allocate the needed memory */
arg2 = (int *)malloc (arg1 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg1; i++) {
PyObject *item = PyList_GetItem (obj0, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateMatND" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMatND *)cvCreateMatND(arg1,(int const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitMatNDHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
int arg2 ;
int *arg3 = (int *) 0 ;
int arg4 ;
void *arg5 = (void *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
int val4 ;
int ecode4 = 0 ;
int res5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMatND *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvInitMatNDHeader",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitMatNDHeader" "', argument " "1"" of type '" "CvMatND *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
{
int i;
/* get the size of the dimention array */
arg2 = PyList_Size (obj1);
/* allocate the needed memory */
arg3 = (int *)malloc (arg2 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg2; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg3 [i] = (int)PyInt_AsLong (item);
}
}
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvInitMatNDHeader" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj3) {
res5 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg5), 0, 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvInitMatNDHeader" "', argument " "5"" of type '" "void *""'");
}
}
{
try {
result = (CvMatND *)cvInitMatNDHeader(arg1,arg2,(int const *)arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneMatND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatND *arg1 = (CvMatND *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatND *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCloneMatND",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCloneMatND" "', argument " "1"" of type '" "CvMatND const *""'");
}
arg1 = reinterpret_cast< CvMatND * >(argp1);
{
try {
result = (CvMatND *)cvCloneMatND((CvMatND const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSparseMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreateSparseMat",&obj0,&obj1)) SWIG_fail;
{
int i;
/* get the size of the dimention array */
arg1 = PyList_Size (obj0);
/* allocate the needed memory */
arg2 = (int *)malloc (arg1 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg1; i++) {
PyObject *item = PyList_GetItem (obj0, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateSparseMat" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvSparseMat *)cvCreateSparseMat(arg1,(int const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneSparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSparseMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCloneSparseMat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCloneSparseMat" "', argument " "1"" of type '" "CvSparseMat const *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
{
try {
result = (CvSparseMat *)cvCloneSparseMat((CvSparseMat const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMat, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitSparseMatIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMat *arg1 = (CvSparseMat *) 0 ;
CvSparseMatIterator *arg2 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSparseNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvInitSparseMatIterator",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitSparseMatIterator" "', argument " "1"" of type '" "CvSparseMat const *""'");
}
arg1 = reinterpret_cast< CvSparseMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitSparseMatIterator" "', argument " "2"" of type '" "CvSparseMatIterator *""'");
}
arg2 = reinterpret_cast< CvSparseMatIterator * >(argp2);
{
try {
result = (CvSparseNode *)cvInitSparseMatIterator((CvSparseMat const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetNextSparseNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSparseNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetNextSparseNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetNextSparseNode" "', argument " "1"" of type '" "CvSparseMatIterator *""'");
}
arg1 = reinterpret_cast< CvSparseMatIterator * >(argp1);
{
try {
result = (CvSparseNode *)cvGetNextSparseNode(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_count_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvNArrayIterator_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_count_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (int) ((arg1)->count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_dims_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_dims_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_dims_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvNArrayIterator_dims_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->dims = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_dims_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_dims_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_dims_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (int) ((arg1)->dims);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
CvSize *arg2 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_size_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_size_set" "', argument " "2"" of type '" "CvSize *""'");
}
arg2 = reinterpret_cast< CvSize * >(argp2);
if (arg1) (arg1)->size = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_size_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (CvSize *)& ((arg1)->size);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
uchar **arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_ptr_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_ptr_set" "', argument " "2"" of type '" "uchar *[10]""'");
}
arg2 = reinterpret_cast< uchar ** >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)10; ++ii) arg1->ptr[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ptr""' of type '""uchar *[10]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_ptr_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (uchar **)(uchar **) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_stack_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
int *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_stack_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_stack_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_stack_set" "', argument " "2"" of type '" "int [32]""'");
}
arg2 = reinterpret_cast< int * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)32; ++ii) arg1->stack[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""stack""' of type '""int [32]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_stack_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_stack_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_stack_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (int *)(int *) ((arg1)->stack);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_hdr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
CvMatND **arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvNArrayIterator_hdr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_hdr_set" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_hdr_set" "', argument " "2"" of type '" "CvMatND *[10]""'");
}
arg2 = reinterpret_cast< CvMatND ** >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)10; ++ii) arg1->hdr[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""hdr""' of type '""CvMatND *[10]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvNArrayIterator_hdr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatND **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvNArrayIterator_hdr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_hdr_get" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
result = (CvMatND **)(CvMatND **) ((arg1)->hdr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvMatND, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvNArrayIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvNArrayIterator")) SWIG_fail;
{
try {
result = (CvNArrayIterator *)new CvNArrayIterator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNArrayIterator, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvNArrayIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvNArrayIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvNArrayIterator" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvNArrayIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvNArrayIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvInitNArrayIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
CvArr **arg2 = (CvArr **) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvMatND *arg4 = (CvMatND *) 0 ;
CvNArrayIterator *arg5 = (CvNArrayIterator *) 0 ;
int arg6 = (int) 0 ;
int val1 ;
int ecode1 = 0 ;
void *vptr2 ;
CvArr *buffer2 ;
bool freearg3 = false ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvInitNArrayIterator",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvInitNArrayIterator" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer2 = (CvArr *) vptr2;
arg2=&buffer2;
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMatND, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvInitNArrayIterator" "', argument " "4"" of type '" "CvMatND *""'");
}
arg4 = reinterpret_cast< CvMatND * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvInitNArrayIterator" "', argument " "5"" of type '" "CvNArrayIterator *""'");
}
arg5 = reinterpret_cast< CvNArrayIterator * >(argp5);
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvInitNArrayIterator" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
result = (int)cvInitNArrayIterator(arg1,arg2,(void const *)arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNextNArraySlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvNextNArraySlice",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvNextNArraySlice" "', argument " "1"" of type '" "CvNArrayIterator *""'");
}
arg1 = reinterpret_cast< CvNArrayIterator * >(argp1);
{
try {
result = (int)cvNextNArraySlice(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetElemType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetElemType",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (int)cvGetElemType((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetDims(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) NULL ;
void *myarr1 ;
int mysizes1[CV_MAX_DIM] ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetDims",&obj0)) SWIG_fail;
{
SWIG_Python_ConvertPtr(obj0, &myarr1, 0, SWIG_POINTER_EXCEPTION);
arg1=(CvArr *)myarr1;
arg2=mysizes1;
}
{
try {
result = (int)cvGetDims((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
int len = PyInt_AsLong( resultobj );
PyObject * obj = PyTuple_FromIntArray( arg2, len );
Py_DECREF( resultobj );
resultobj = obj;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetDimSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetDimSize",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetDimSize" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (int)cvGetDimSize((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPtr1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int *arg3 = (int *) NULL ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvPtr1D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPtr1D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvPtr1D" "', argument " "3"" of type '" "int *""'");
}
arg3 = reinterpret_cast< int * >(argp3);
}
{
try {
result = (uchar *)cvPtr1D((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPtr2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int *arg4 = (int *) NULL ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvPtr2D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPtr2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPtr2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvPtr2D" "', argument " "4"" of type '" "int *""'");
}
arg4 = reinterpret_cast< int * >(argp4);
}
{
try {
result = (uchar *)cvPtr2D((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPtr3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int *arg5 = (int *) NULL ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvPtr3D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvPtr3D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPtr3D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvPtr3D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvPtr3D" "', argument " "5"" of type '" "int *""'");
}
arg5 = reinterpret_cast< int * >(argp5);
}
{
try {
result = (uchar *)cvPtr3D((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPtrND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
int *arg3 = (int *) NULL ;
int arg4 = (int) 1 ;
unsigned int *arg5 = (unsigned int *) NULL ;
bool freearg1 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOO:cvPtrND",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvPtrND" "', argument " "3"" of type '" "int *""'");
}
arg3 = reinterpret_cast< int * >(argp3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvPtrND" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_int, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvPtrND" "', argument " "5"" of type '" "unsigned int *""'");
}
arg5 = reinterpret_cast< unsigned int * >(argp5);
}
{
try {
result = (uchar *)cvPtrND((void const *)arg1,(int const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGet1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGet1D",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGet1D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvGet1D((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGet2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGet2D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGet2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGet2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = cvGet2D((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGet3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvGet3D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGet3D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGet3D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGet3D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = cvGet3D((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetND",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
{
try {
result = cvGetND((void const *)arg1,(int const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetReal1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetReal1D",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetReal1D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (double)cvGetReal1D((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetReal2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetReal2D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetReal2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetReal2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvGetReal2D((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetReal3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvGetReal3D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetReal3D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetReal3D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetReal3D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (double)cvGetReal3D((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRealND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetRealND",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
{
try {
result = (double)cvGetRealND((void const *)arg1,(int const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSet1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
CvScalar arg3 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSet1D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSet1D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
try {
cvSet1D(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSet2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
CvScalar arg4 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvSet2D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSet2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSet2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
arg4 = PyObject_to_CvScalar( obj3 );
}
{
try {
cvSet2D(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSet3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvScalar arg5 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSet3D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSet3D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSet3D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSet3D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
arg5 = PyObject_to_CvScalar( obj4 );
}
{
try {
cvSet3D(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
CvScalar arg3 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSetND",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
try {
cvSetND(arg1,(int const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetReal1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
double arg3 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSetReal1D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetReal1D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetReal1D" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
cvSetReal1D(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetReal2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
double arg4 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvSetReal2D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetReal2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetReal2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSetReal2D" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
{
try {
cvSetReal2D(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetReal3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
double arg5 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSetReal3D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetReal3D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetReal3D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSetReal3D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSetReal3D" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
{
try {
cvSetReal3D(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetRealND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
double arg3 ;
bool freearg1 = false ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSetRealND",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetRealND" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
cvSetRealND(arg1,(int const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int *arg2 = (int *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvClearND",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int size;
/* get the size of the dimention array */
size = PyList_Size (obj1);
/* allocate the needed memory */
arg2 = (int *)malloc (size * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj1, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
{
try {
cvClearND(arg1,(int const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int *arg3 = (int *) NULL ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
CvMat *header2 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvGetMat",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetMat" "', argument " "3"" of type '" "int *""'");
}
arg3 = reinterpret_cast< int * >(argp3);
}
if (obj2) {
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetMat" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (CvMat *)cvGetMat((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReshapeMatND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 ;
int arg5 ;
int *arg6 = (int *) 0 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvArr *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvReshapeMatND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvReshapeMatND" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReshapeMatND" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvReshapeMatND" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvReshapeMatND" "', argument " "6"" of type '" "int *""'");
}
arg6 = reinterpret_cast< int * >(argp6);
{
try {
result = (CvArr *)cvReshapeMatND((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReshape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
CvMat *header2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
{
header2 = (CvMat *)cvAlloc(sizeof(CvMat));
arg2 = header2;
}
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvReshape",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReshape" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj2) {
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReshape" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (CvMat *)cvReshape((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 );
{
arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount;
arg2->refcount = ((CvMat *)arg1)->refcount;
cvIncRefData(arg2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRepeat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvRepeat",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvRepeat((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCreateData",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
cvCreateData(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseData",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
cvReleaseData(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
bool freearg1 = false ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSetData",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSetData" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetData" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvSetData(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
uchar **arg2 = (uchar **) 0 ;
int *arg3 = (int *) NULL ;
CvSize *arg4 = (CvSize *) NULL ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvGetRawData",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetRawData" "', argument " "2"" of type '" "uchar **""'");
}
arg2 = reinterpret_cast< uchar ** >(argp2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetRawData" "', argument " "3"" of type '" "int *""'");
}
arg3 = reinterpret_cast< int * >(argp3);
}
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvGetRawData" "', argument " "4"" of type '" "CvSize *""'");
}
arg4 = reinterpret_cast< CvSize * >(argp4);
}
{
try {
cvGetRawData((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetSize",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = cvGetSize((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvCopy",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
{
try {
cvCopy((void const *)arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSet",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
{
try {
cvSet(arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSetZero",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
cvSetZero(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSplit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
bool freearg5 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSplit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
{
try {
cvSplit((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMerge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
bool freearg5 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvMerge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
{
try {
cvMerge((void const *)arg1,(void const *)arg2,(void const *)arg3,(void const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMixChannels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr **arg1 = (CvArr **) 0 ;
int arg2 ;
CvArr **arg3 = (CvArr **) 0 ;
int arg4 ;
int *arg5 = (int *) 0 ;
int arg6 ;
void *vptr1 ;
CvArr *buffer1 ;
int val2 ;
int ecode2 = 0 ;
void *vptr3 ;
CvArr *buffer3 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvMixChannels",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer1 = (CvArr *) vptr1;
arg1=&buffer1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMixChannels" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvArr *) vptr3;
arg3=&buffer3;
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMixChannels" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvMixChannels" "', argument " "5"" of type '" "int const *""'");
}
arg5 = reinterpret_cast< int * >(argp5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvMixChannels" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
cvMixChannels((void const **)arg1,arg2,arg3,arg4,(int const *)arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvertScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 = (double) 1 ;
double arg4 = (double) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvConvertScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvConvertScale" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvConvertScale" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvConvertScale((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvertScaleAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 = (double) 1 ;
double arg4 = (double) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvConvertScaleAbs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvConvertScaleAbs" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvConvertScaleAbs" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvConvertScaleAbs((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCheckTermCriteria(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTermCriteria arg1 ;
double arg2 ;
int arg3 ;
void *argp1 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvTermCriteria result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCheckTermCriteria",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCheckTermCriteria" "', argument " "1"" of type '" "CvTermCriteria""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCheckTermCriteria" "', argument " "1"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCheckTermCriteria" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCheckTermCriteria" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = cvCheckTermCriteria(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvTermCriteria(static_cast< const CvTermCriteria& >(result))), SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvAdd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvAdd((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAddS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvAddS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvAddS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSub",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvSub((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSubS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvSubS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubRS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSubRS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvSubRS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 = (double) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvMul",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMul" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvMul((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 = (double) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvDiv",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvDiv" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvDiv((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvScaleAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvScaleAdd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvScaleAdd((void const *)arg1,arg2,(void const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAddWeighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 ;
double arg5 ;
CvArr *arg6 = (CvArr *) 0 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
bool freearg6 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvAddWeighted",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvAddWeighted" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvAddWeighted" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvAddWeighted" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
{
try {
cvAddWeighted((void const *)arg1,arg2,(void const *)arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvDotProduct",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
result = (double)cvDotProduct((void const *)arg1,(void const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvAnd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvAnd((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAndS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvAndS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvAndS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvOr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvOr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvOr((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvOrS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvOrS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvOrS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvXor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvXor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvXor((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvXorS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvXorS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvXorS((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvNot",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvNot((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvInRange",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvInRange((void const *)arg1,(void const *)arg2,(void const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInRangeS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 ;
CvScalar arg3 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvInRangeS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvScalar( obj1 );
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvInRangeS((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCmp",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCmp" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
cvCmp((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCmpS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCmpS",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCmpS" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCmpS" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
cvCmpS((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMin",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvMin((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMax",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvMax((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMinS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMinS",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMinS" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvMinS((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMaxS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMaxS",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMaxS" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvMaxS((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAbsDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvAbsDiff",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvAbsDiff((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAbsDiffS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvScalar arg3 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvAbsDiffS",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
try {
cvAbsDiffS((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCartToPolar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
int arg5 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvCartToPolar",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCartToPolar" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvCartToPolar((void const *)arg1,(void const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPolarToCart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
int arg5 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvPolarToCart",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvPolarToCart" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvPolarToCart((void const *)arg1,(void const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvPow",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPow" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
cvPow((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvExp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvExp",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvExp((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvLog",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvLog((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFastArctan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float arg2 ;
float val1 ;
int ecode1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvFastArctan",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvFastArctan" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvFastArctan" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
{
try {
result = (float)cvFastArctan(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCbrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float arg1 ;
float val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:cvCbrt",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_float(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCbrt" "', argument " "1"" of type '" "float""'");
}
arg1 = static_cast< float >(val1);
{
try {
result = (float)cvCbrt(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCheckArr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 = (int) 0 ;
double arg3 = (double) 0 ;
double arg4 = (double) 0 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O|OOO:cvCheckArr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCheckArr" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCheckArr" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCheckArr" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
result = (int)cvCheckArr((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRandArr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRNG *arg1 = (CvRNG *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
CvScalar arg4 ;
CvScalar arg5 ;
void *vptr1 ;
CvRNG_Wrapper *wrapper1 ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvRandArr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
if(SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Python object to C value");
return NULL;
}
wrapper1 = (CvRNG_Wrapper *) vptr1;
arg1 = wrapper1->ptr();
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRandArr" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
arg4 = PyObject_to_CvScalar( obj3 );
}
{
arg5 = PyObject_to_CvScalar( obj4 );
}
{
try {
cvRandArr(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRandShuffle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvRNG *arg2 = (CvRNG *) 0 ;
double arg3 = (double) 1. ;
bool freearg1 = false ;
void *vptr2 ;
CvRNG_Wrapper *wrapper2 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvRandShuffle",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
if(SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Python object to C value");
return NULL;
}
wrapper2 = (CvRNG_Wrapper *) vptr2;
arg2 = wrapper2->ptr();
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRandShuffle" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
{
try {
cvRandShuffle(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) NULL ;
CvArr *arg3 = (CvArr *) NULL ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|OOO:cvSort",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSort" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvSort((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSolveCubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSolveCubic",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSolveCubic" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSolveCubic" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
{
try {
result = (int)cvSolveCubic((CvMat const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSolvePoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 = (int) 0 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvSolvePoly",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSolvePoly" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSolvePoly" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSolvePoly" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSolvePoly" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvSolvePoly((CvMat const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCrossProduct",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvCrossProduct((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGEMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
CvArr *arg4 = (CvArr *) 0 ;
double arg5 ;
CvArr *arg6 = (CvArr *) 0 ;
int arg7 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
double val5 ;
int ecode5 = 0 ;
bool freearg6 = false ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|O:cvGEMM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGEMM" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvGEMM" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvGEMM" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvGEMM((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvTransform",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvTransform" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvTransform" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
}
{
try {
cvTransform((void const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPerspectiveTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvPerspectiveTransform",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvPerspectiveTransform" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
cvPerspectiveTransform((void const *)arg1,arg2,(CvMat const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMulTransposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
CvArr *arg4 = (CvArr *) NULL ;
double arg5 = (double) 1. ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvMulTransposed",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMulTransposed" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
if (obj4) {
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvMulTransposed" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
{
try {
cvMulTransposed((void const *)arg1,arg2,arg3,(void const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvTranspose",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvTranspose((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCompleteSymm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvCompleteSymm",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCompleteSymm" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCompleteSymm" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
cvCompleteSymm(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFlip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) NULL ;
int arg3 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvFlip",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvFlip" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvFlip((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSVD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) NULL ;
CvArr *arg4 = (CvArr *) NULL ;
int arg5 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOO:cvSVD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSVD" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvSVD(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSVBkSb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
int arg6 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
bool freearg5 = false ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvSVBkSb",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvSVBkSb" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
cvSVBkSb((void const *)arg1,(void const *)arg2,(void const *)arg3,(void const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvInvert",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInvert" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = (double)cvInvert((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSolve",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSolve" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (int)cvSolve((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:cvDet",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (double)cvDet((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTrace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O:cvTrace",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = cvTrace((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEigenVV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 = (double) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvEigenVV",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEigenVV" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvEigenVV(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar arg2 = (CvScalar) cvRealScalar(1) ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSetIdentity",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg2 = PyObject_to_CvScalar( obj1 );
}
}
{
try {
cvSetIdentity(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double arg2 ;
double arg3 ;
bool freearg1 = false ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvArr *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvRange",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRange" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRange" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = (CvArr *)cvRange(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcCovarMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr **arg1 = (CvArr **) 0 ;
int arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
int arg5 ;
CvArr *one_image1 = NULL ;
bool free_one_arg1 = false ;
CvArr **many_images1 = NULL ;
bool *free_many_args1 = NULL ;
int nimages1 = 0 ;
int val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCalcCovarMatrix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
/* first, check if this is a tuple */
if PyTuple_Check (obj0) {
/* This is a tuple, so we need to test each element and pass
them to the called function */
int i;
/* get the size of the tuple */
nimages1 = PyTuple_Size (obj0);
/* allocate the necessary place */
many_images1 = (CvArr **)malloc (nimages1 * sizeof (CvArr *));
free_many_args1 = (bool *)malloc(nimages1 * sizeof(bool));
for (i = 0; i < nimages1; i++) {
/* convert the current tuple element to a CvArr *, and
store to many_images1 [i] */
many_images1[i] = PyObject_to_CvArr (PyTuple_GetItem (obj0, i),
free_many_args1+i);
/* check that the current item is a correct type */
if(!many_images1[i]) {
/* incorrect ! */
SWIG_fail;
}
}
/* what to give to the called function */
arg1 = many_images1;
} else if((one_image1 = PyObject_to_CvArr( obj0, &free_one_arg1 ))){
/* this is just one CvArr *, so one_image1 will receive it */
arg1 = &one_image1;
} else {
/* not a CvArr *, not a tuple, this is wrong */
SWIG_fail;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCalcCovarMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcCovarMatrix" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
cvCalcCovarMatrix((void const **)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcPCA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
int arg5 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCalcPCA",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcPCA" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
cvCalcPCA((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvProjectPCA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvProjectPCA",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvProjectPCA((void const *)arg1,(void const *)arg2,(void const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvBackProjectPCA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvBackProjectPCA",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvBackProjectPCA((void const *)arg1,(void const *)arg2,(void const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMahalanobis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvMahalanobis",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
result = (double)cvMahalanobis((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O:cvSum",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = cvSum((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCountNonZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvCountNonZero",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (int)cvCountNonZero((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvAvg",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
}
{
try {
result = cvAvg((void const *)arg1,(void const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAvgSdv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvScalar *arg2 = (CvScalar *) 0 ;
CvScalar *arg3 = (CvScalar *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvAvgSdv",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvAvgSdv" "', argument " "2"" of type '" "CvScalar *""'");
}
arg2 = reinterpret_cast< CvScalar * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvAvgSdv" "', argument " "3"" of type '" "CvScalar *""'");
}
arg3 = reinterpret_cast< CvScalar * >(argp3);
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvAvgSdv((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMinMaxLoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
double *arg2 = (double *) 0 ;
double *arg3 = (double *) 0 ;
CvPoint *arg4 = (CvPoint *) NULL ;
CvPoint *arg5 = (CvPoint *) NULL ;
CvArr *arg6 = (CvArr *) NULL ;
bool freearg1 = false ;
double temp2 ;
int res2 = SWIG_TMPOBJ ;
double temp3 ;
int res3 = SWIG_TMPOBJ ;
bool freearg6 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
arg2 = &temp2;
arg3 = &temp3;
{
arg4 = (CvPoint *) malloc(sizeof(CvPoint));
}
{
arg5 = (CvPoint *) malloc(sizeof(CvPoint));
}
if (!PyArg_ParseTuple(args,(char *)"O|O:cvMinMaxLoc",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg6 = PyObject_to_CvArr(obj1, &freearg6);
}
}
{
try {
cvMinMaxLoc((void const *)arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
}
if (SWIG_IsTmpObj(res3)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
} else {
int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
}
{
PyObject * to_add = SWIG_NewPointerObj (arg4, SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN);
resultobj = SWIG_Python_AppendOutput(resultobj, to_add);
}
{
PyObject * to_add = SWIG_NewPointerObj (arg5, SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN);
resultobj = SWIG_Python_AppendOutput(resultobj, to_add);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) NULL ;
int arg3 = (int) 4 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O|OOO:cvNorm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvNorm" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
result = (double)cvNorm((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNormalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 = (double) 1. ;
double arg4 = (double) 0. ;
int arg5 = (int) 4 ;
CvArr *arg6 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
bool freearg6 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:cvNormalize",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvNormalize" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvNormalize" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvNormalize" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
}
{
try {
cvNormalize((void const *)arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReduce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) -1 ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvReduce",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReduce" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReduce" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvReduce((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDFT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
int arg4 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvDFT",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvDFT" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvDFT" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvDFT((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMulSpectrums(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMulSpectrums",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMulSpectrums" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
cvMulSpectrums((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetOptimalDFTSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetOptimalDFTSize",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvGetOptimalDFTSize" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (int)cvGetOptimalDFTSize(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDCT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvDCT",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvDCT" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvDCT((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSliceLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSlice arg1 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSliceLength",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSliceLength" "', argument " "1"" of type '" "CvSlice""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSliceLength" "', argument " "1"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
{
try {
result = (int)cvSliceLength(arg1,(CvSeq const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateMemStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 = (int) 0 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"|O:cvCreateMemStorage",&obj0)) SWIG_fail;
if (obj0) {
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateMemStorage" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
}
{
try {
result = (CvMemStorage *)cvCreateMemStorage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateChildMemStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCreateChildMemStorage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateChildMemStorage" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
{
try {
result = (CvMemStorage *)cvCreateChildMemStorage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearMemStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearMemStorage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvClearMemStorage" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
{
try {
cvClearMemStorage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSaveMemStoragePos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
CvMemStoragePos *arg2 = (CvMemStoragePos *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSaveMemStoragePos",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSaveMemStoragePos" "', argument " "1"" of type '" "CvMemStorage const *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSaveMemStoragePos" "', argument " "2"" of type '" "CvMemStoragePos *""'");
}
arg2 = reinterpret_cast< CvMemStoragePos * >(argp2);
{
try {
cvSaveMemStoragePos((CvMemStorage const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRestoreMemStoragePos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
CvMemStoragePos *arg2 = (CvMemStoragePos *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvRestoreMemStoragePos",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRestoreMemStoragePos" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStoragePos, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRestoreMemStoragePos" "', argument " "2"" of type '" "CvMemStoragePos *""'");
}
arg2 = reinterpret_cast< CvMemStoragePos * >(argp2);
{
try {
cvRestoreMemStoragePos(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMemStorageAlloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
size_t arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
size_t val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvMemStorageAlloc",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvMemStorageAlloc" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
ecode2 = SWIG_AsVal_size_t(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMemStorageAlloc" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
{
try {
result = (void *)cvMemStorageAlloc(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMemStorageAllocString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMemStorage *arg1 = (CvMemStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 = (int) -1 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvString result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvMemStorageAllocString",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvMemStorageAllocString" "', argument " "1"" of type '" "CvMemStorage *""'");
}
arg1 = reinterpret_cast< CvMemStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMemStorageAllocString" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMemStorageAllocString" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = cvMemStorageAllocString(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvString(static_cast< const CvString& >(result))), SWIGTYPE_p_CvString, SWIG_POINTER_OWN | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMemStorage *arg4 = (CvMemStorage *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCreateSeq",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateSeq" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateSeq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateSeq" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCreateSeq" "', argument " "4"" of type '" "CvMemStorage *""'");
}
arg4 = reinterpret_cast< CvMemStorage * >(argp4);
{
try {
result = (CvSeq *)cvCreateSeq(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetSeqBlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSetSeqBlockSize",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetSeqBlockSize" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
cvSetSeqBlockSize(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) NULL ;
void *ptr1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSeqPush",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPush" "', argument " "2"" of type '" "void *""'");
}
}
{
try {
result = (schar *)cvSeqPush(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPushFront(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) NULL ;
void *ptr1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSeqPushFront",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPushFront" "', argument " "2"" of type '" "void *""'");
}
}
{
try {
result = (schar *)cvSeqPushFront(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) NULL ;
void *ptr1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSeqPop",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPop" "', argument " "2"" of type '" "void *""'");
}
}
{
try {
cvSeqPop(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPopFront(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) NULL ;
void *ptr1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSeqPopFront",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPopFront" "', argument " "2"" of type '" "void *""'");
}
}
{
try {
cvSeqPopFront(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPushMulti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
int arg4 = (int) 0 ;
void *ptr1 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSeqPushMulti",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPushMulti" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSeqPushMulti" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSeqPushMulti" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvSeqPushMulti(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPopMulti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
int arg4 = (int) 0 ;
void *ptr1 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvSeqPopMulti",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPopMulti" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSeqPopMulti" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSeqPopMulti" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvSeqPopMulti(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqInsert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *arg3 = (void *) NULL ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSeqInsert",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSeqInsert" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSeqInsert" "', argument " "3"" of type '" "void *""'");
}
}
{
try {
result = (schar *)cvSeqInsert(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqRemove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSeqRemove",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSeqRemove" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
cvSeqRemove(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearSeq",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
cvClearSeq(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSeqElem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetSeqElem",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetSeqElem" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (schar *)cvGetSeqElem((CvSeq const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqElemIdx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) 0 ;
CvSeqBlock **arg3 = (CvSeqBlock **) NULL ;
void *ptr1 ;
int res2 ;
void *vptr3 ;
CvSeqBlock *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSeqElemIdx",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqElemIdx" "', argument " "2"" of type '" "void const *""'");
}
if (obj2) {
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvSeqBlock, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvSeqBlock *) vptr3;
arg3=&buffer3;
}
}
{
try {
result = (int)cvSeqElemIdx((CvSeq const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartAppendToSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeqWriter *arg2 = (CvSeqWriter *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvStartAppendToSeq",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartAppendToSeq" "', argument " "2"" of type '" "CvSeqWriter *""'");
}
arg2 = reinterpret_cast< CvSeqWriter * >(argp2);
{
try {
cvStartAppendToSeq(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartWriteSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMemStorage *arg4 = (CvMemStorage *) 0 ;
CvSeqWriter *arg5 = (CvSeqWriter *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvStartWriteSeq",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvStartWriteSeq" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvStartWriteSeq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvStartWriteSeq" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStartWriteSeq" "', argument " "4"" of type '" "CvMemStorage *""'");
}
arg4 = reinterpret_cast< CvMemStorage * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvStartWriteSeq" "', argument " "5"" of type '" "CvSeqWriter *""'");
}
arg5 = reinterpret_cast< CvSeqWriter * >(argp5);
{
try {
cvStartWriteSeq(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEndWriteSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvEndWriteSeq",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvEndWriteSeq" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
{
try {
result = (CvSeq *)cvEndWriteSeq(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFlushSeqWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvFlushSeqWriter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFlushSeqWriter" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
{
try {
cvFlushSeqWriter(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartReadSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSeqReader *arg2 = (CvSeqReader *) 0 ;
int arg3 = (int) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvStartReadSeq",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartReadSeq" "', argument " "2"" of type '" "CvSeqReader *""'");
}
arg2 = reinterpret_cast< CvSeqReader * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvStartReadSeq" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvStartReadSeq((CvSeq const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSeqReaderPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetSeqReaderPos",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetSeqReaderPos" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
{
try {
result = (int)cvGetSeqReaderPos(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetSeqReaderPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqReader *arg1 = (CvSeqReader *) 0 ;
int arg2 ;
int arg3 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSetSeqReaderPos",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSetSeqReaderPos" "', argument " "1"" of type '" "CvSeqReader *""'");
}
arg1 = reinterpret_cast< CvSeqReader * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetSeqReaderPos" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetSeqReaderPos" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvSetSeqReaderPos(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMakeSeqHeaderForArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
void *arg4 = (void *) 0 ;
int arg5 ;
CvSeq *arg6 = (CvSeq *) 0 ;
CvSeqBlock *arg7 = (CvSeqBlock *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
int val5 ;
int ecode5 = 0 ;
void *ptr6 ;
void *argp7 = 0 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cvMakeSeqHeaderForArray",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvMakeSeqHeaderForArray" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvMakeSeqHeaderForArray" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMakeSeqHeaderForArray" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMakeSeqHeaderForArray" "', argument " "4"" of type '" "void *""'");
}
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvMakeSeqHeaderForArray" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
if( SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj5, &ptr6, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg6 = (CvSeq *) ptr6;
}
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvMakeSeqHeaderForArray" "', argument " "7"" of type '" "CvSeqBlock *""'");
}
arg7 = reinterpret_cast< CvSeqBlock * >(argp7);
{
try {
result = (CvSeq *)cvMakeSeqHeaderForArray(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSlice arg2 ;
CvMemStorage *arg3 = (CvMemStorage *) NULL ;
int arg4 = (int) 0 ;
void *ptr1 ;
void *argp2 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvSeqSlice",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqSlice" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSeqSlice" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSeqSlice" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSeqSlice" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (CvSeq *)cvSeqSlice((CvSeq const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) NULL ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvCloneSeq",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCloneSeq" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
}
{
try {
result = (CvSeq *)cvCloneSeq((CvSeq const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqRemoveSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvSlice arg2 ;
void *ptr1 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSeqRemoveSlice",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqRemoveSlice" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSeqRemoveSlice" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
try {
cvSeqRemoveSlice(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqInsertSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
int arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvSeqInsertSlice",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSeqInsertSlice" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvSeqInsertSlice(arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqSort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvCmpFunc arg2 = (CvCmpFunc) 0 ;
void *arg3 = (void *) NULL ;
void *ptr1 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSeqSort",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void_p_q_const__void_p_void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSeqSort" "', argument " "2"" of type '" "CvCmpFunc""'");
}
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSeqSort" "', argument " "3"" of type '" "void *""'");
}
}
{
try {
cvSeqSort(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqSearch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *arg2 = (void *) 0 ;
CvCmpFunc arg3 = (CvCmpFunc) 0 ;
int arg4 ;
int *arg5 = (int *) 0 ;
void *arg6 = (void *) NULL ;
void *ptr1 ;
int res2 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int res6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvSeqSearch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqSearch" "', argument " "2"" of type '" "void const *""'");
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_q_const__void_p_q_const__void_p_void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSeqSearch" "', argument " "3"" of type '" "CvCmpFunc""'");
}
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSeqSearch" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvSeqSearch" "', argument " "5"" of type '" "int *""'");
}
arg5 = reinterpret_cast< int * >(argp5);
if (obj5) {
res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvSeqSearch" "', argument " "6"" of type '" "void *""'");
}
}
{
try {
result = (schar *)cvSeqSearch(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqInvert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSeqInvert",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
cvSeqInvert(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSeqPartition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
CvSeq **arg3 = (CvSeq **) 0 ;
CvCmpFunc arg4 = (CvCmpFunc) 0 ;
void *arg5 = (void *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *vptr3 ;
CvSeq *buffer3 ;
int res5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSeqPartition",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSeqPartition" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvSeq, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvSeq *) vptr3;
arg3=&buffer3;
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_q_const__void_p_q_const__void_p_void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSeqPartition" "', argument " "4"" of type '" "CvCmpFunc""'");
}
}
res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvSeqPartition" "', argument " "5"" of type '" "void *""'");
}
{
try {
result = (int)cvSeqPartition((CvSeq const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvChangeSeqBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int arg2 ;
int res1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvChangeSeqBlock",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvChangeSeqBlock" "', argument " "1"" of type '" "void *""'");
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvChangeSeqBlock" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
cvChangeSeqBlock(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSeqBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeqWriter *arg1 = (CvSeqWriter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCreateSeqBlock",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateSeqBlock" "', argument " "1"" of type '" "CvSeqWriter *""'");
}
arg1 = reinterpret_cast< CvSeqWriter * >(argp1);
{
try {
cvCreateSeqBlock(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMemStorage *arg4 = (CvMemStorage *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvSet *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCreateSet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateSet" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateSet" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateSet" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCreateSet" "', argument " "4"" of type '" "CvMemStorage *""'");
}
arg4 = reinterpret_cast< CvMemStorage * >(argp4);
{
try {
result = (CvSet *)cvCreateSet(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
CvSetElem *arg2 = (CvSetElem *) NULL ;
CvSetElem **arg3 = (CvSetElem **) NULL ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *vptr3 ;
CvSetElem *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvSetAdd",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSetElem, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSetAdd" "', argument " "2"" of type '" "CvSetElem *""'");
}
arg2 = reinterpret_cast< CvSetElem * >(argp2);
}
if (obj2) {
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvSetElem, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvSetElem *) vptr3;
arg3=&buffer3;
}
}
{
try {
result = (int)cvSetAdd(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSetNew",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
try {
result = (CvSetElem *)cvSetNew(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetRemoveByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *arg2 = (void *) 0 ;
void *ptr1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSetRemoveByPtr",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSetRemoveByPtr" "', argument " "2"" of type '" "void *""'");
}
{
try {
cvSetRemoveByPtr(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetRemove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSetRemove",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSetRemove" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
cvSetRemove(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSetElem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetSetElem",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetSetElem" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvSetElem *)cvGetSetElem((CvSet const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSet *arg1 = (CvSet *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearSet",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
return NULL;
}
arg1 = (CvSet *)ptr1;
}
{
try {
cvClearSet(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMemStorage *arg5 = (CvMemStorage *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvGraph *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCreateGraph",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateGraph" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateGraph" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateGraph" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCreateGraph" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCreateGraph" "', argument " "5"" of type '" "CvMemStorage *""'");
}
arg5 = reinterpret_cast< CvMemStorage * >(argp5);
{
try {
result = (CvGraph *)cvCreateGraph(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphAddVtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) NULL ;
CvGraphVtx **arg3 = (CvGraphVtx **) NULL ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *vptr3 ;
CvGraphVtx *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvGraphAddVtx",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphAddVtx" "', argument " "2"" of type '" "CvGraphVtx const *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
}
if (obj2) {
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvGraphVtx, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvGraphVtx *) vptr3;
arg3=&buffer3;
}
}
{
try {
result = (int)cvGraphAddVtx(arg1,(CvGraphVtx const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphRemoveVtx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphRemoveVtx",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGraphRemoveVtx" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (int)cvGraphRemoveVtx(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphRemoveVtxByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphRemoveVtxByPtr",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphRemoveVtxByPtr" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
{
try {
result = (int)cvGraphRemoveVtxByPtr(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphAddEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
int arg3 ;
CvGraphEdge *arg4 = (CvGraphEdge *) NULL ;
CvGraphEdge **arg5 = (CvGraphEdge **) NULL ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *vptr5 ;
CvGraphEdge *buffer5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvGraphAddEdge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGraphAddEdge" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGraphAddEdge" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvGraphAddEdge" "', argument " "4"" of type '" "CvGraphEdge const *""'");
}
arg4 = reinterpret_cast< CvGraphEdge * >(argp4);
}
if (obj4) {
{
if ((SWIG_ConvertPtr(obj4, &vptr5, SWIGTYPE_p_CvGraphEdge, 1)) == -1){
SWIG_fail;
}
buffer5 = (CvGraphEdge *) vptr5;
arg5=&buffer5;
}
}
{
try {
result = (int)cvGraphAddEdge(arg1,arg2,arg3,(CvGraphEdge const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphAddEdgeByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
CvGraphVtx *arg3 = (CvGraphVtx *) 0 ;
CvGraphEdge *arg4 = (CvGraphEdge *) NULL ;
CvGraphEdge **arg5 = (CvGraphEdge **) NULL ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *vptr5 ;
CvGraphEdge *buffer5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvGraphAddEdgeByPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphAddEdgeByPtr" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGraphAddEdgeByPtr" "', argument " "3"" of type '" "CvGraphVtx *""'");
}
arg3 = reinterpret_cast< CvGraphVtx * >(argp3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvGraphEdge, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvGraphAddEdgeByPtr" "', argument " "4"" of type '" "CvGraphEdge const *""'");
}
arg4 = reinterpret_cast< CvGraphEdge * >(argp4);
}
if (obj4) {
{
if ((SWIG_ConvertPtr(obj4, &vptr5, SWIGTYPE_p_CvGraphEdge, 1)) == -1){
SWIG_fail;
}
buffer5 = (CvGraphEdge *) vptr5;
arg5=&buffer5;
}
}
{
try {
result = (int)cvGraphAddEdgeByPtr(arg1,arg2,arg3,(CvGraphEdge const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphRemoveEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
int arg3 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGraphRemoveEdge",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGraphRemoveEdge" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGraphRemoveEdge" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvGraphRemoveEdge(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphRemoveEdgeByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
CvGraphVtx *arg3 = (CvGraphVtx *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGraphRemoveEdgeByPtr",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphRemoveEdgeByPtr" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGraphRemoveEdgeByPtr" "', argument " "3"" of type '" "CvGraphVtx *""'");
}
arg3 = reinterpret_cast< CvGraphVtx * >(argp3);
{
try {
cvGraphRemoveEdgeByPtr(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindGraphEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
int arg3 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvFindGraphEdge",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvFindGraphEdge" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvFindGraphEdge" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvGraphEdge *)cvFindGraphEdge((CvGraph const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindGraphEdgeByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
CvGraphVtx *arg3 = (CvGraphVtx *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvFindGraphEdgeByPtr",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindGraphEdgeByPtr" "', argument " "2"" of type '" "CvGraphVtx const *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindGraphEdgeByPtr" "', argument " "3"" of type '" "CvGraphVtx const *""'");
}
arg3 = reinterpret_cast< CvGraphVtx * >(argp3);
{
try {
result = (CvGraphEdge *)cvFindGraphEdgeByPtr((CvGraph const *)arg1,(CvGraphVtx const *)arg2,(CvGraphVtx const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearGraph",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
{
try {
cvClearGraph(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphVtxDegree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
int arg2 ;
void *ptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphVtxDegree",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGraphVtxDegree" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (int)cvGraphVtxDegree((CvGraph const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGraphVtxDegreeByPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGraphVtxDegreeByPtr",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphVtxDegreeByPtr" "', argument " "2"" of type '" "CvGraphVtx const *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
{
try {
result = (int)cvGraphVtxDegreeByPtr((CvGraph const *)arg1,(CvGraphVtx const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_vtx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_vtx_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_vtx_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphScanner_vtx_set" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
if (arg1) (arg1)->vtx = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_vtx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphVtx *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_vtx_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_vtx_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (CvGraphVtx *) ((arg1)->vtx);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_dst_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_dst_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_dst_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphScanner_dst_set" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
if (arg1) (arg1)->dst = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_dst_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphVtx *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_dst_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_dst_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (CvGraphVtx *) ((arg1)->dst);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_edge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
CvGraphEdge *arg2 = (CvGraphEdge *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_edge_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_edge_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphScanner_edge_set" "', argument " "2"" of type '" "CvGraphEdge *""'");
}
arg2 = reinterpret_cast< CvGraphEdge * >(argp2);
if (arg1) (arg1)->edge = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_edge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraphEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_edge_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_edge_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (CvGraphEdge *) ((arg1)->edge);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_graph_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
CvGraph *arg2 = (CvGraph *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_graph_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_graph_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg2 = (CvGraph *)ptr2;
}
if (arg1) (arg1)->graph = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_graph_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvGraph *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_graph_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_graph_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (CvGraph *) ((arg1)->graph);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_stack_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_stack_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_stack_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->stack = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_stack_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_stack_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_stack_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (CvSeq *) ((arg1)->stack);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_index_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphScanner_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_index_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (int) ((arg1)->index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_mask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvGraphScanner_mask_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_mask_set" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphScanner_mask_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->mask = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvGraphScanner_mask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvGraphScanner_mask_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_mask_get" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
result = (int) ((arg1)->mask);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvGraphScanner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvGraphScanner",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphScanner" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
{
try {
delete_CvGraphScanner(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvGraphScanner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvGraphScanner, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvCreateGraphScanner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvGraphVtx *arg2 = (CvGraphVtx *) NULL ;
int arg3 = (int) -1 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvGraphScanner *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvCreateGraphScanner",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCreateGraphScanner" "', argument " "2"" of type '" "CvGraphVtx *""'");
}
arg2 = reinterpret_cast< CvGraphVtx * >(argp2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateGraphScanner" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = (CvGraphScanner *)cvCreateGraphScanner(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphScanner, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNextGraphItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraphScanner *arg1 = (CvGraphScanner *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvNextGraphItem",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvNextGraphItem" "', argument " "1"" of type '" "CvGraphScanner *""'");
}
arg1 = reinterpret_cast< CvGraphScanner * >(argp1);
{
try {
result = (int)cvNextGraphItem(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCloneGraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvGraph *arg1 = (CvGraph *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvGraph *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCloneGraph",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
return NULL;
}
arg1 = (CvGraph *)ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCloneGraph" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
{
try {
result = (CvGraph *)cvCloneGraph((CvGraph const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvPoint arg3 ;
CvScalar arg4 ;
int arg5 = (int) 1 ;
int arg6 = (int) 8 ;
int arg7 = (int) 0 ;
bool freearg1 = false ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OOO:cvLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
arg3 = PyObject_to_CvPoint(obj2);
}
{
arg4 = PyObject_to_CvScalar( obj3 );
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvLine" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvLine" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvLine" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvLine(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvPoint arg3 ;
CvScalar arg4 ;
int arg5 = (int) 1 ;
int arg6 = (int) 8 ;
int arg7 = (int) 0 ;
bool freearg1 = false ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OOO:cvRectangle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
arg3 = PyObject_to_CvPoint(obj2);
}
{
arg4 = PyObject_to_CvScalar( obj3 );
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvRectangle" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvRectangle" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvRectangle" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
int arg3 ;
CvScalar arg4 ;
int arg5 = (int) 1 ;
int arg6 = (int) 8 ;
int arg7 = (int) 0 ;
bool freearg1 = false ;
int val3 ;
int ecode3 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OOO:cvCircle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCircle" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
arg4 = PyObject_to_CvScalar( obj3 );
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCircle" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCircle" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvCircle" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvCircle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEllipse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvSize arg3 ;
double arg4 ;
double arg5 ;
double arg6 ;
CvScalar arg7 ;
int arg8 = (int) 1 ;
int arg9 = (int) 8 ;
int arg10 = (int) 0 ;
bool freearg1 = false ;
void *argp3 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
int val8 ;
int ecode8 = 0 ;
int val9 ;
int ecode9 = 0 ;
int val10 ;
int ecode10 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO|OOO:cvEllipse",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvEllipse" "', argument " "3"" of type '" "CvSize""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvEllipse" "', argument " "3"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEllipse" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvEllipse" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvEllipse" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
{
arg7 = PyObject_to_CvScalar( obj6 );
}
if (obj7) {
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvEllipse" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
}
if (obj8) {
ecode9 = SWIG_AsVal_int(obj8, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvEllipse" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
}
if (obj9) {
ecode10 = SWIG_AsVal_int(obj9, &val10);
if (!SWIG_IsOK(ecode10)) {
SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "cvEllipse" "', argument " "10"" of type '" "int""'");
}
arg10 = static_cast< int >(val10);
}
{
try {
cvEllipse(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEllipseBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvBox2D arg2 ;
CvScalar arg3 ;
int arg4 = (int) 1 ;
int arg5 = (int) 8 ;
int arg6 = (int) 0 ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOO:cvEllipseBox",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvBox2D, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvEllipseBox" "', argument " "2"" of type '" "CvBox2D""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvEllipseBox" "', argument " "2"" of type '" "CvBox2D""'");
} else {
CvBox2D * temp = reinterpret_cast< CvBox2D * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEllipseBox" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvEllipseBox" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvEllipseBox" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvEllipseBox(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFillConvexPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
int arg3 ;
CvScalar arg4 ;
int arg5 = (int) 8 ;
int arg6 = (int) 0 ;
bool freearg1 = false ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvFillConvexPoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
if(!PySequence_Check(obj1)){
SWIG_exception(SWIG_TypeError, "Expected a list for argument 2\n");
return NULL;
}
int size = PySequence_Size(obj1);
CvPoint * points = (CvPoint *)malloc(size*sizeof(CvPoint));
for(i=0; i<size; i++){
PyObject *item = PySequence_GetItem(obj1, i);
points[i] = PyObject_to_CvPoint( item );
}
arg2 = points;
arg3 = size;
}
{
arg4 = PyObject_to_CvScalar( obj2 );
}
if (obj3) {
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFillConvexPoly" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj4) {
ecode6 = SWIG_AsVal_int(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFillConvexPoly" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvFillConvexPoly(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
free((char *)arg2);
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
free((char *)arg2);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFillPoly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint **arg2 = (CvPoint **) 0 ;
int *arg3 = (int *) 0 ;
int arg4 ;
CvScalar arg5 ;
int arg6 = (int) 8 ;
int arg7 = (int) 0 ;
bool freearg1 = false ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvFillPoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int j;
int size2 = -1;
CvPoint **points = NULL;
int *nb_vertex = NULL;
if(!PySequence_Check(obj1)){
SWIG_exception(SWIG_TypeError, "Expected a list for argument 2\n");
return NULL;
}
/* get the number of polylines input array */
int size1 = PySequence_Size (obj1);
arg4 = size1;
if(size1>0){
/* create the points array */
points = (CvPoint **)malloc (size1 * sizeof (CvPoint *));
/* point to the created array for passing info to the C function */
arg2 = points;
/* create the array for memorizing the vertex */
nb_vertex = (int *)malloc (size1 * sizeof (int));
arg3 = nb_vertex;
}
for (i = 0; i < size1; i++) {
/* get the current item */
PyObject *line = PySequence_GetItem (obj1, i);
if(!PySequence_Check(line)){
SWIG_exception(SWIG_TypeError, "Expected a sequence of sequences of integers for argument 2\n");
// TODO: cleanup here
}
/* get the size of the current polyline */
size2 = PySequence_Size (line);
if(size2>0){
/* allocate the necessary memory to store the points */
points [i] = (CvPoint *)malloc (size2 * sizeof (CvPoint));
}
/* memorize the size of the polyline in the vertex list */
nb_vertex [i] = size2;
for (j = 0; j < size2; j++) {
/* get the current item */
PyObject *item = PySequence_GetItem (line, j);
points[i][j] = PyObject_to_CvPoint( item );
}
}
}
{
arg5 = PyObject_to_CvScalar( obj2 );
}
if (obj3) {
ecode6 = SWIG_AsVal_int(obj3, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFillPoly" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj4) {
ecode7 = SWIG_AsVal_int(obj4, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvFillPoly" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvFillPoly(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
int i;
for(i=0;i<arg4;i++){
free(arg2[i]);
}
free(arg2);
free(arg3);
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
int i;
for(i=0;i<arg4;i++){
free(arg2[i]);
}
free(arg2);
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPolyLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint **arg2 = (CvPoint **) 0 ;
int *arg3 = (int *) 0 ;
int arg4 ;
int arg5 ;
CvScalar arg6 ;
int arg7 = (int) 1 ;
int arg8 = (int) 8 ;
int arg9 = (int) 0 ;
bool freearg1 = false ;
int val5 ;
int ecode5 = 0 ;
int val7 ;
int ecode7 = 0 ;
int val8 ;
int ecode8 = 0 ;
int val9 ;
int ecode9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OOO:cvPolyLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
int j;
int size2 = -1;
CvPoint **points = NULL;
int *nb_vertex = NULL;
if(!PySequence_Check(obj1)){
SWIG_exception(SWIG_TypeError, "Expected a list for argument 2\n");
return NULL;
}
/* get the number of polylines input array */
int size1 = PySequence_Size (obj1);
arg4 = size1;
if(size1>0){
/* create the points array */
points = (CvPoint **)malloc (size1 * sizeof (CvPoint *));
/* point to the created array for passing info to the C function */
arg2 = points;
/* create the array for memorizing the vertex */
nb_vertex = (int *)malloc (size1 * sizeof (int));
arg3 = nb_vertex;
}
for (i = 0; i < size1; i++) {
/* get the current item */
PyObject *line = PySequence_GetItem (obj1, i);
if(!PySequence_Check(line)){
SWIG_exception(SWIG_TypeError, "Expected a sequence of sequences of integers for argument 2\n");
// TODO: cleanup here
}
/* get the size of the current polyline */
size2 = PySequence_Size (line);
if(size2>0){
/* allocate the necessary memory to store the points */
points [i] = (CvPoint *)malloc (size2 * sizeof (CvPoint));
}
/* memorize the size of the polyline in the vertex list */
nb_vertex [i] = size2;
for (j = 0; j < size2; j++) {
/* get the current item */
PyObject *item = PySequence_GetItem (line, j);
points[i][j] = PyObject_to_CvPoint( item );
}
}
}
ecode5 = SWIG_AsVal_int(obj2, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvPolyLine" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
arg6 = PyObject_to_CvScalar( obj3 );
}
if (obj4) {
ecode7 = SWIG_AsVal_int(obj4, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvPolyLine" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
if (obj5) {
ecode8 = SWIG_AsVal_int(obj5, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvPolyLine" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
}
if (obj6) {
ecode9 = SWIG_AsVal_int(obj6, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvPolyLine" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
}
{
try {
cvPolyLine(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
int i;
for(i=0;i<arg4;i++){
free(arg2[i]);
}
free(arg2);
free(arg3);
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
int i;
for(i=0;i<arg4;i++){
free(arg2[i]);
}
free(arg2);
free(arg3);
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClipLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize arg1 ;
CvPoint *arg2 = (CvPoint *) 0 ;
CvPoint *arg3 = (CvPoint *) 0 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvClipLine",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvClipLine" "', argument " "1"" of type '" "CvSize""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvClipLine" "', argument " "1"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvClipLine" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvClipLine" "', argument " "3"" of type '" "CvPoint *""'");
}
arg3 = reinterpret_cast< CvPoint * >(argp3);
{
try {
result = (int)cvClipLine(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitLineIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvPoint arg3 ;
CvLineIterator *arg4 = (CvLineIterator *) 0 ;
int arg5 = (int) 8 ;
int arg6 = (int) 0 ;
bool freearg1 = false ;
void *argp4 = 0 ;
int res4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvInitLineIterator",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
arg3 = PyObject_to_CvPoint(obj2);
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvLineIterator, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvInitLineIterator" "', argument " "4"" of type '" "CvLineIterator *""'");
}
arg4 = reinterpret_cast< CvLineIterator * >(argp4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvInitLineIterator" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvInitLineIterator" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
result = (int)cvInitLineIterator((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_font_face_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_font_face_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_font_face_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_font_face_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->font_face = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_font_face_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_font_face_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_font_face_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int) ((arg1)->font_face);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_ascii_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_ascii_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_ascii_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFont_ascii_set" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->ascii = (int const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_ascii_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_ascii_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_ascii_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int *) ((arg1)->ascii);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_greek_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_greek_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_greek_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFont_greek_set" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->greek = (int const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_greek_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_greek_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_greek_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int *) ((arg1)->greek);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_cyrillic_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_cyrillic_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_cyrillic_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFont_cyrillic_set" "', argument " "2"" of type '" "int const *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->cyrillic = (int const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_cyrillic_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_cyrillic_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_cyrillic_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int *) ((arg1)->cyrillic);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_hscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_hscale_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_hscale_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_hscale_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->hscale = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_hscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_hscale_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_hscale_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (float) ((arg1)->hscale);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_vscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_vscale_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_vscale_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_vscale_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->vscale = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_vscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_vscale_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_vscale_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (float) ((arg1)->vscale);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_shear_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_shear_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_shear_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_shear_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->shear = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_shear_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_shear_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_shear_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (float) ((arg1)->shear);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_thickness_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_thickness_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_thickness_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_thickness_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->thickness = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_thickness_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_thickness_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_thickness_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int) ((arg1)->thickness);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_dx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_dx_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_dx_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_dx_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->dx = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_dx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_dx_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_dx_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (float) ((arg1)->dx);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_line_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvFont_line_type_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_line_type_set" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_line_type_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->line_type = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvFont_line_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvFont_line_type_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_line_type_get" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
result = (int) ((arg1)->line_type);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvFont")) SWIG_fail;
{
try {
result = (CvFont *)new CvFont();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFont, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvFont",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFont, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFont" "', argument " "1"" of type '" "CvFont *""'");
}
arg1 = reinterpret_cast< CvFont * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvFont_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvFont, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvInitFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFont *arg1 = (CvFont *) 0 ;
int arg2 ;
double arg3 ;
double arg4 ;
double arg5 = (double) 0 ;
int arg6 = (int) 1 ;
int arg7 = (int) 8 ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOO:cvInitFont",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = (CvFont *)malloc (sizeof (CvFont));
arg2 = (int)PyInt_AsLong (obj0);
if (SWIG_arg_fail(1)) SWIG_fail;
}
ecode3 = SWIG_AsVal_double(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInitFont" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvInitFont" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
if (obj3) {
ecode5 = SWIG_AsVal_double(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvInitFont" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
if (obj4) {
ecode6 = SWIG_AsVal_int(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvInitFont" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj5) {
ecode7 = SWIG_AsVal_int(obj5, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvInitFont" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
cvInitFont(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
PyObject *to_add;
/* extract the pointer we want to add to the returned tuple */
to_add = SWIG_NewPointerObj (arg1, SWIGTYPE_p_CvFont, 0);
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
int arg2 = (int) 1 ;
double val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvFont result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvFont",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvFont" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvFont" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = cvFont(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvFont(static_cast< const CvFont& >(result))), SWIGTYPE_p_CvFont, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPutText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
char *arg2 = (char *) 0 ;
CvPoint arg3 ;
CvFont *arg4 = (CvFont *) 0 ;
CvScalar arg5 ;
bool freearg1 = false ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvPutText",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvPutText" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
arg3 = PyObject_to_CvPoint(obj2);
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvPutText" "', argument " "4"" of type '" "CvFont const *""'");
}
arg4 = reinterpret_cast< CvFont * >(argp4);
{
arg5 = PyObject_to_CvScalar( obj4 );
}
{
try {
cvPutText(arg1,(char const *)arg2,arg3,(CvFont const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetTextSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvFont *arg2 = (CvFont *) 0 ;
CvSize *arg3 = (CvSize *) 0 ;
int *arg4 = (int *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
{
CvSize *size = (CvSize *)malloc (sizeof (CvSize));
int *baseline = (int *)malloc (sizeof (int));
arg3 = size;
arg4 = baseline;
}
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetTextSize",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetTextSize" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFont, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetTextSize" "', argument " "2"" of type '" "CvFont const *""'");
}
arg2 = reinterpret_cast< CvFont * >(argp2);
{
try {
cvGetTextSize((char const *)arg1,(CvFont const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
PyObject * to_add[2];
/* extract the pointers we want to add to the returned tuple */
to_add [0] = SWIG_NewPointerObj (arg3, SWIGTYPE_p_CvSize, 0);
to_add [1] = PyInt_FromLong (*arg4);
resultobj = SWIG_AppendResult(resultobj, to_add, 2);
}
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvColorToScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
int arg2 ;
double val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvScalar result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvColorToScalar",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvColorToScalar" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvColorToScalar" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvColorToScalar(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvScalar(static_cast< const CvScalar& >(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEllipse2Poly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint arg1 ;
CvSize arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvPoint *arg6 = (CvPoint *) 0 ;
int arg7 ;
void *argp2 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cvEllipse2Poly",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint(obj0);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvEllipse2Poly" "', argument " "2"" of type '" "CvSize""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvEllipse2Poly" "', argument " "2"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvEllipse2Poly" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEllipse2Poly" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvEllipse2Poly" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvEllipse2Poly" "', argument " "6"" of type '" "CvPoint *""'");
}
arg6 = reinterpret_cast< CvPoint * >(argp6);
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvEllipse2Poly" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
result = (int)cvEllipse2Poly(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDrawContours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
CvScalar arg3 ;
CvScalar arg4 ;
int arg5 ;
int arg6 = (int) 1 ;
int arg7 = (int) 8 ;
CvPoint arg8 = (CvPoint) cvPoint(0,0) ;
bool freearg1 = false ;
void *ptr2 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|OOO:cvDrawContours",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
{
arg4 = PyObject_to_CvScalar( obj3 );
}
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvDrawContours" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvDrawContours" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvDrawContours" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
if (obj7) {
{
arg8 = PyObject_to_CvPoint(obj7);
}
}
{
try {
cvDrawContours(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLUT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvLUT",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
try {
cvLUT((void const *)arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_node_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *arg2 = (void *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTreeNodeIterator_node_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_node_set" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTreeNodeIterator_node_set" "', argument " "2"" of type '" "void const *""'");
}
if (arg1) (arg1)->node = (void const *)arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_node_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTreeNodeIterator_node_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_node_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
result = (void *) ((arg1)->node);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTreeNodeIterator_level_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_level_set" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTreeNodeIterator_level_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->level = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTreeNodeIterator_level_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_level_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
result = (int) ((arg1)->level);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_max_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTreeNodeIterator_max_level_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_max_level_set" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTreeNodeIterator_max_level_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->max_level = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTreeNodeIterator_max_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvTreeNodeIterator_max_level_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_max_level_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
result = (int) ((arg1)->max_level);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTreeNodeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTreeNodeIterator")) SWIG_fail;
{
try {
result = (CvTreeNodeIterator *)new CvTreeNodeIterator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTreeNodeIterator, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTreeNodeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTreeNodeIterator",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTreeNodeIterator" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTreeNodeIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTreeNodeIterator, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvInitTreeNodeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvInitTreeNodeIterator",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitTreeNodeIterator" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitTreeNodeIterator" "', argument " "2"" of type '" "void const *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInitTreeNodeIterator" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvInitTreeNodeIterator(arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNextTreeNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvNextTreeNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvNextTreeNode" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
{
try {
result = (void *)cvNextTreeNode(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPrevTreeNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvPrevTreeNode",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvPrevTreeNode" "', argument " "1"" of type '" "CvTreeNodeIterator *""'");
}
arg1 = reinterpret_cast< CvTreeNodeIterator * >(argp1);
{
try {
result = (void *)cvPrevTreeNode(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInsertNodeIntoTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
void *arg2 = (void *) 0 ;
void *arg3 = (void *) 0 ;
int res1 ;
int res2 ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvInsertNodeIntoTree",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInsertNodeIntoTree" "', argument " "1"" of type '" "void *""'");
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInsertNodeIntoTree" "', argument " "2"" of type '" "void *""'");
}
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvInsertNodeIntoTree" "', argument " "3"" of type '" "void *""'");
}
{
try {
cvInsertNodeIntoTree(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRemoveNodeFromTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
void *arg2 = (void *) 0 ;
int res1 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvRemoveNodeFromTree",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRemoveNodeFromTree" "', argument " "1"" of type '" "void *""'");
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRemoveNodeFromTree" "', argument " "2"" of type '" "void *""'");
}
{
try {
cvRemoveNodeFromTree(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTreeToNodeSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int arg2 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
int res1 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvTreeToNodeSeq",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvTreeToNodeSeq" "', argument " "1"" of type '" "void const *""'");
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvTreeToNodeSeq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvTreeToNodeSeq" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
{
try {
result = (CvSeq *)cvTreeToNodeSeq((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvKMeans2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
CvArr *arg3 = (CvArr *) 0 ;
CvTermCriteria arg4 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
bool freearg3 = false ;
void *argp4 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvKMeans2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvKMeans2" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvKMeans2" "', argument " "4"" of type '" "CvTermCriteria""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvKMeans2" "', argument " "4"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
try {
cvKMeans2((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRegisterModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvRegisterModule",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRegisterModule" "', argument " "1"" of type '" "CvModuleInfo const *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
{
try {
result = (int)cvRegisterModule((CvModuleInfo const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvUseOptimized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvUseOptimized",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvUseOptimized" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (int)cvUseOptimized(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetModuleInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char **arg2 = (char **) 0 ;
char **arg3 = (char **) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
void *vptr2 ;
char *buffer2 ;
void *vptr3 ;
char *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetModuleInfo",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetModuleInfo" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer2 = (char *) vptr2;
arg2=&buffer2;
}
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer3 = (char *) vptr3;
arg3=&buffer3;
}
{
try {
cvGetModuleInfo((char const *)arg1,(char const **)arg2,(char const **)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetErrStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int result;
if (!PyArg_ParseTuple(args,(char *)":cvGetErrStatus")) SWIG_fail;
{
try {
result = (int)cvGetErrStatus();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetErrStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSetErrStatus",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSetErrStatus" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
cvSetErrStatus(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetErrMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int result;
if (!PyArg_ParseTuple(args,(char *)":cvGetErrMode")) SWIG_fail;
{
try {
result = (int)cvGetErrMode();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetErrMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvSetErrMode",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSetErrMode" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (int)cvSetErrMode(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvError",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvError" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvError" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvError" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvError" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvError" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
cvError(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvErrorStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvErrorStr",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvErrorStr" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (char *)cvErrorStr(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetErrInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char **arg1 = (char **) 0 ;
char **arg2 = (char **) 0 ;
char **arg3 = (char **) 0 ;
int *arg4 = (int *) 0 ;
void *vptr1 ;
char *buffer1 ;
void *vptr2 ;
char *buffer2 ;
void *vptr3 ;
char *buffer3 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvGetErrInfo",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer1 = (char *) vptr1;
arg1=&buffer1;
}
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer2 = (char *) vptr2;
arg2=&buffer2;
}
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer3 = (char *) vptr3;
arg3=&buffer3;
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvGetErrInfo" "', argument " "4"" of type '" "int *""'");
}
arg4 = reinterpret_cast< int * >(argp4);
{
try {
result = (int)cvGetErrInfo((char const **)arg1,(char const **)arg2,(char const **)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvErrorFromIppStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvErrorFromIppStatus",&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvErrorFromIppStatus" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
try {
result = (int)cvErrorFromIppStatus(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRedirectError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvErrorCallback arg1 = (CvErrorCallback) 0 ;
void *arg2 = (void *) NULL ;
void **arg3 = (void **) NULL ;
int res2 ;
void *vptr3 ;
void *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvErrorCallback result;
if (!PyArg_ParseTuple(args,(char *)"O|OO:cvRedirectError",&obj0,&obj1,&obj2)) SWIG_fail;
{
int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvRedirectError" "', argument " "1"" of type '" "CvErrorCallback""'");
}
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRedirectError" "', argument " "2"" of type '" "void *""'");
}
}
if (obj2) {
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_void, 1)) == -1){
SWIG_fail;
}
buffer3 = (void *) vptr3;
arg3=&buffer3;
}
}
{
try {
result = (CvErrorCallback)cvRedirectError(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNulDevReport(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
void *arg6 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int res6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvNulDevReport",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvNulDevReport" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvNulDevReport" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvNulDevReport" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvNulDevReport" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvNulDevReport" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvNulDevReport" "', argument " "6"" of type '" "void *""'");
}
{
try {
result = (int)cvNulDevReport(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStdErrReport(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
void *arg6 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int res6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvStdErrReport",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvStdErrReport" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStdErrReport" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvStdErrReport" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStdErrReport" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvStdErrReport" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvStdErrReport" "', argument " "6"" of type '" "void *""'");
}
{
try {
result = (int)cvStdErrReport(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGuiBoxReport(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
void *arg6 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int res6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvGuiBoxReport",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvGuiBoxReport" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGuiBoxReport" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGuiBoxReport" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvGuiBoxReport" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvGuiBoxReport" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvGuiBoxReport" "', argument " "6"" of type '" "void *""'");
}
{
try {
result = (int)cvGuiBoxReport(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetMemoryManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAllocFunc arg1 = (CvAllocFunc) NULL ;
CvFreeFunc arg2 = (CvFreeFunc) NULL ;
void *arg3 = (void *) NULL ;
int res3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"|OOO:cvSetMemoryManager",&obj0,&obj1,&obj2)) SWIG_fail;
if (obj0) {
{
int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_size_t_p_void__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetMemoryManager" "', argument " "1"" of type '" "CvAllocFunc""'");
}
}
}
if (obj1) {
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetMemoryManager" "', argument " "2"" of type '" "CvFreeFunc""'");
}
}
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSetMemoryManager" "', argument " "3"" of type '" "void *""'");
}
}
{
try {
cvSetMemoryManager(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetIPLAllocators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Cv_iplCreateImageHeader arg1 = (Cv_iplCreateImageHeader) 0 ;
Cv_iplAllocateImageData arg2 = (Cv_iplAllocateImageData) 0 ;
Cv_iplDeallocate arg3 = (Cv_iplDeallocate) 0 ;
Cv_iplCreateROI arg4 = (Cv_iplCreateROI) 0 ;
Cv_iplCloneImage arg5 = (Cv_iplCloneImage) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSetIPLAllocators",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetIPLAllocators" "', argument " "1"" of type '" "Cv_iplCreateImageHeader""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p__IplImage_int_int__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetIPLAllocators" "', argument " "2"" of type '" "Cv_iplAllocateImageData""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p__IplImage_int__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetIPLAllocators" "', argument " "3"" of type '" "Cv_iplDeallocate""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_int_int_int_int_int__p__IplROI);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetIPLAllocators" "', argument " "4"" of type '" "Cv_iplCreateROI""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj4, (void**)(&arg5), SWIGTYPE_p_f_p_q_const__IplImage__p__IplImage);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetIPLAllocators" "', argument " "5"" of type '" "Cv_iplCloneImage""'");
}
}
{
try {
cvSetIPLAllocators(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvOpenFileStorage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
int arg3 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvFileStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvOpenFileStorage",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvOpenFileStorage" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvOpenFileStorage" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvOpenFileStorage" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvFileStorage *)cvOpenFileStorage((char const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileStorage, SWIG_POINTER_OWN | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAttrValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAttrList *arg1 = (CvAttrList *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvAttrValue",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvAttrValue" "', argument " "1"" of type '" "CvAttrList const *""'");
}
arg1 = reinterpret_cast< CvAttrList * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvAttrValue" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
result = (char *)cvAttrValue((CvAttrList const *)arg1,(char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartWriteStruct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
char *arg4 = (char *) NULL ;
CvAttrList arg5 = (CvAttrList) cvAttrList() ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvStartWriteStruct",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStartWriteStruct" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartWriteStruct" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvStartWriteStruct" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStartWriteStruct" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
}
if (obj4) {
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvAttrList, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvStartWriteStruct" "', argument " "5"" of type '" "CvAttrList""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvStartWriteStruct" "', argument " "5"" of type '" "CvAttrList""'");
} else {
CvAttrList * temp = reinterpret_cast< CvAttrList * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
}
{
try {
cvStartWriteStruct(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEndWriteStruct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvEndWriteStruct",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvEndWriteStruct" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
{
try {
cvEndWriteStruct(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvWriteInt",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteInt" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteInt" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvWriteInt" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvWriteInt(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
double arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvWriteReal",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteReal" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteReal" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvWriteReal" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
cvWriteReal(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvWriteString",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteString" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteString" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvWriteString" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvWriteString" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvWriteString(arg1,(char const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvWriteComment",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteComment" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteComment" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvWriteComment" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvWriteComment(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
void *arg3 = (void *) 0 ;
CvAttrList arg4 = (CvAttrList) cvAttrList() ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
void *argp4 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvWrite",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWrite" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWrite" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvWrite" "', argument " "3"" of type '" "void const *""'");
}
if (obj3) {
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvAttrList, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvWrite" "', argument " "4"" of type '" "CvAttrList""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvWrite" "', argument " "4"" of type '" "CvAttrList""'");
} else {
CvAttrList * temp = reinterpret_cast< CvAttrList * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
}
{
try {
cvWrite(arg1,(char const *)arg2,(void const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartNextStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvStartNextStream",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStartNextStream" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
{
try {
cvStartNextStream(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteRawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
char *arg4 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvWriteRawData",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteRawData" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteRawData" "', argument " "2"" of type '" "void const *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvWriteRawData" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvWriteRawData" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
{
try {
cvWriteRawData(arg1,(void const *)arg2,arg3,(char const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetHashedKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 = (int) -1 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvStringHashNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvGetHashedKey",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetHashedKey" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetHashedKey" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetHashedKey" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetHashedKey" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (CvStringHashNode *)cvGetHashedKey(arg1,(char const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRootFileNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
int arg2 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvFileNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvGetRootFileNode",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetRootFileNode" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetRootFileNode" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = (CvFileNode *)cvGetRootFileNode((CvFileStorage const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetFileNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
CvStringHashNode *arg3 = (CvStringHashNode *) 0 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvFileNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvGetFileNode",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetFileNode" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetFileNode" "', argument " "2"" of type '" "CvFileNode *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvStringHashNode, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetFileNode" "', argument " "3"" of type '" "CvStringHashNode const *""'");
}
arg3 = reinterpret_cast< CvStringHashNode * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetFileNode" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (CvFileNode *)cvGetFileNode(arg1,arg2,(CvStringHashNode const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetFileNodeByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvFileNode *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetFileNodeByName",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetFileNodeByName" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetFileNodeByName" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetFileNodeByName" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
result = (CvFileNode *)cvGetFileNodeByName((CvFileStorage const *)arg1,(CvFileNode const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode, 0 | 0 );
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
int arg2 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvReadInt",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadInt" "', argument " "1"" of type '" "CvFileNode const *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvReadInt" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = (int)cvReadInt((CvFileNode const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadIntByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvReadIntByName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadIntByName" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadIntByName" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReadIntByName" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReadIntByName" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
result = (int)cvReadIntByName((CvFileStorage const *)arg1,(CvFileNode const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
double arg2 = (double) 0. ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvReadReal",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadReal" "', argument " "1"" of type '" "CvFileNode const *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
if (obj1) {
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvReadReal" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
}
{
try {
result = (double)cvReadReal((CvFileNode const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadRealByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
char *arg3 = (char *) 0 ;
double arg4 = (double) 0. ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvReadRealByName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadRealByName" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadRealByName" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReadRealByName" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReadRealByName" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
result = (double)cvReadRealByName((CvFileStorage const *)arg1,(CvFileNode const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
char *arg2 = (char *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvReadString",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadString" "', argument " "1"" of type '" "CvFileNode const *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
if (obj1) {
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadString" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
}
{
try {
result = (char *)cvReadString((CvFileNode const *)arg1,(char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadStringByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvReadStringByName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadStringByName" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadStringByName" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReadStringByName" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
if (obj3) {
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvReadStringByName" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
}
{
try {
result = (char *)cvReadStringByName((CvFileStorage const *)arg1,(CvFileNode const *)arg2,(char const *)arg3,(char const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
CvAttrList *arg3 = (CvAttrList *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvRead",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRead" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRead" "', argument " "2"" of type '" "CvFileNode *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRead" "', argument " "3"" of type '" "CvAttrList *""'");
}
arg3 = reinterpret_cast< CvAttrList * >(argp3);
}
{
try {
result = (void *)cvRead(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
char *arg3 = (char *) 0 ;
CvAttrList *arg4 = (CvAttrList *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvReadByName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadByName" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadByName" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReadByName" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvAttrList, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvReadByName" "', argument " "4"" of type '" "CvAttrList *""'");
}
arg4 = reinterpret_cast< CvAttrList * >(argp4);
}
{
try {
result = (void *)cvReadByName(arg1,(CvFileNode const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartReadRawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
CvSeqReader *arg3 = (CvSeqReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvStartReadRawData",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStartReadRawData" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartReadRawData" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvStartReadRawData" "', argument " "3"" of type '" "CvSeqReader *""'");
}
arg3 = reinterpret_cast< CvSeqReader * >(argp3);
{
try {
cvStartReadRawData((CvFileStorage const *)arg1,(CvFileNode const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadRawDataSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvSeqReader *arg2 = (CvSeqReader *) 0 ;
int arg3 ;
void *arg4 = (void *) 0 ;
char *arg5 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
int res5 ;
char *buf5 = 0 ;
int alloc5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvReadRawDataSlice",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadRawDataSlice" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqReader, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadRawDataSlice" "', argument " "2"" of type '" "CvSeqReader *""'");
}
arg2 = reinterpret_cast< CvSeqReader * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReadRawDataSlice" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvReadRawDataSlice" "', argument " "4"" of type '" "void *""'");
}
res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvReadRawDataSlice" "', argument " "5"" of type '" "char const *""'");
}
arg5 = reinterpret_cast< char * >(buf5);
{
try {
cvReadRawDataSlice((CvFileStorage const *)arg1,arg2,arg3,arg4,(char const *)arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
return resultobj;
fail:
if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadRawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
CvFileNode *arg2 = (CvFileNode *) 0 ;
void *arg3 = (void *) 0 ;
char *arg4 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvReadRawData",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadRawData" "', argument " "1"" of type '" "CvFileStorage const *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvReadRawData" "', argument " "2"" of type '" "CvFileNode const *""'");
}
arg2 = reinterpret_cast< CvFileNode * >(argp2);
res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReadRawData" "', argument " "3"" of type '" "void *""'");
}
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvReadRawData" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
{
try {
cvReadRawData((CvFileStorage const *)arg1,(CvFileNode const *)arg2,arg3,(char const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWriteFileNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
CvFileNode *arg3 = (CvFileNode *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvWriteFileNode",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvWriteFileNode" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvWriteFileNode" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvWriteFileNode" "', argument " "3"" of type '" "CvFileNode const *""'");
}
arg3 = reinterpret_cast< CvFileNode * >(argp3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvWriteFileNode" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
cvWriteFileNode(arg1,(char const *)arg2,(CvFileNode const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetFileNodeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileNode *arg1 = (CvFileNode *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetFileNodeName",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetFileNodeName" "', argument " "1"" of type '" "CvFileNode const *""'");
}
arg1 = reinterpret_cast< CvFileNode * >(argp1);
{
try {
result = (char *)cvGetFileNodeName((CvFileNode const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRegisterType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *arg1 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvRegisterType",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRegisterType" "', argument " "1"" of type '" "CvTypeInfo const *""'");
}
arg1 = reinterpret_cast< CvTypeInfo * >(argp1);
{
try {
cvRegisterType((CvTypeInfo const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvUnregisterType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvUnregisterType",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvUnregisterType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
try {
cvUnregisterType((char const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFirstType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":cvFirstType")) SWIG_fail;
{
try {
result = (CvTypeInfo *)cvFirstType();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvFindType",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
try {
result = (CvTypeInfo *)cvFindType((char const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTypeOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int res1 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvTypeOf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvTypeOf" "', argument " "1"" of type '" "void const *""'");
}
{
try {
result = (CvTypeInfo *)cvTypeOf((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
int res1 ;
PyObject * obj0 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClone",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvClone" "', argument " "1"" of type '" "void const *""'");
}
{
try {
result = (void *)cvClone((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
void *arg2 = (void *) 0 ;
char *arg3 = (char *) NULL ;
char *arg4 = (char *) NULL ;
CvAttrList arg5 = (CvAttrList) cvAttrList() ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOO:cvSave",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSave" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSave" "', argument " "2"" of type '" "void const *""'");
}
if (obj2) {
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSave" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
}
if (obj3) {
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvSave" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
}
if (obj4) {
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvAttrList, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvSave" "', argument " "5"" of type '" "CvAttrList""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSave" "', argument " "5"" of type '" "CvAttrList""'");
} else {
CvAttrList * temp = reinterpret_cast< CvAttrList * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
}
{
try {
cvSave((char const *)arg1,(void const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLoad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) NULL ;
char *arg3 = (char *) NULL ;
char **arg4 = (char **) NULL ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
void *vptr4 ;
char *buffer4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|OOO:cvLoad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvLoad" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvLoad" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
}
if (obj2) {
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvLoad" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
}
if (obj3) {
{
if ((SWIG_ConvertPtr(obj3, &vptr4, SWIGTYPE_p_char, 1)) == -1){
SWIG_fail;
}
buffer4 = (char *) vptr4;
arg4=&buffer4;
}
}
{
try {
result = (void *)cvLoad((char const *)arg1,arg2,(char const *)arg3,(char const **)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetTickCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int64 result;
if (!PyArg_ParseTuple(args,(char *)":cvGetTickCount")) SWIG_fail;
{
try {
result = (int64)cvGetTickCount();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_long_SS_long(static_cast< int64 >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetTickFrequency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double result;
if (!PyArg_ParseTuple(args,(char *)":cvGetTickFrequency")) SWIG_fail;
{
try {
result = (double)cvGetTickFrequency();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetNumThreads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int result;
if (!PyArg_ParseTuple(args,(char *)":cvGetNumThreads")) SWIG_fail;
{
try {
result = (int)cvGetNumThreads();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetNumThreads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 = (int) 0 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"|O:cvSetNumThreads",&obj0)) SWIG_fail;
if (obj0) {
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSetNumThreads" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
}
{
try {
cvSetNumThreads(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetThreadNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int result;
if (!PyArg_ParseTuple(args,(char *)":cvGetThreadNum")) SWIG_fail;
{
try {
result = (int)cvGetThreadNum();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetImageIOFunctions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLoadImageFunc arg1 = (CvLoadImageFunc) 0 ;
CvLoadImageMFunc arg2 = (CvLoadImageMFunc) 0 ;
CvSaveImageFunc arg3 = (CvSaveImageFunc) 0 ;
CvShowImageFunc arg4 = (CvShowImageFunc) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvSetImageIOFunctions",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
int res = SWIG_ConvertFunctionPtr(obj0, (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_int__p__IplImage);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetImageIOFunctions" "', argument " "1"" of type '" "CvLoadImageFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_int__p_CvMat);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetImageIOFunctions" "', argument " "2"" of type '" "CvLoadImageMFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_q_const__char_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetImageIOFunctions" "', argument " "3"" of type '" "CvSaveImageFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_q_const__char_p_q_const__void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvSetImageIOFunctions" "', argument " "4"" of type '" "CvShowImageFunc""'");
}
}
{
try {
result = (int)cvSetImageIOFunctions(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvImage")) SWIG_fail;
{
try {
result = (CvImage *)new CvImage();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSize arg1 ;
int arg2 ;
int arg3 ;
void *argp1 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvImage",&obj0,&obj1,&obj2)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "CvSize""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvImage" "', argument " "1"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvImage" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvImage" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvImage *)new CvImage(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage header1 ;
PyObject * obj0 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvImage",&obj0)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
try {
result = (CvImage *)new CvImage(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvImage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvImage, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "CvImage const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvImage" "', argument " "1"" of type '" "CvImage const &""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (CvImage *)new CvImage((CvImage const &)*arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvImage",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvImage" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvImage" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvImage *)new CvImage((char const *)arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_CvImage",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvImage" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
result = (CvImage *)new CvImage((char const *)arg1,(char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvImage",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
try {
result = (CvImage *)new CvImage((char const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvImage",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvImage" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvImage" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
result = (CvImage *)new CvImage(arg1,(char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvImage",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvImage" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvImage" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvImage" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvImage *)new CvImage(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvImage, SWIG_POINTER_NEW | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvImage(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvImage__SWIG_0(self, args);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvImage__SWIG_2(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvImage__SWIG_3(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvImage__SWIG_6(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvImage__SWIG_5(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvImage__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvImage__SWIG_8(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvImage__SWIG_7(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvImage__SWIG_4(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvImage'.\n"
" Possible C/C++ prototypes are:\n"
" CvImage()\n"
" CvImage(CvSize,int,int)\n"
" CvImage(IplImage *)\n"
" CvImage(CvImage const &)\n"
" CvImage(char const *,char const *,int)\n"
" CvImage(char const *,char const *)\n"
" CvImage(char const *)\n"
" CvImage(CvFileStorage *,char const *,char const *)\n"
" CvImage(CvFileStorage *,char const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvImage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvImage" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvImage result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_clone",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_clone" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (arg1)->clone();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvImage(static_cast< const CvImage& >(result))), SWIGTYPE_p_CvImage, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
CvSize arg2 ;
int arg3 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvImage_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_create" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_create" "', argument " "2"" of type '" "CvSize""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvImage_create" "', argument " "2"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvImage_create" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvImage_create" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
(arg1)->create(arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_release",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_release" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
(arg1)->release();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_clear" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_attach__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
IplImage *arg2 = (IplImage *) 0 ;
bool arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
IplImage header2 ;
bool val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvImage_attach",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_attach" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
void * vptr;
int res = SWIG_ConvertPtr(obj1, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg2 = cvGetImage((CvMat *)vptr, &header2);
}
ecode3 = SWIG_AsVal_bool(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvImage_attach" "', argument " "3"" of type '" "bool""'");
}
arg3 = static_cast< bool >(val3);
{
try {
(arg1)->attach(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_attach__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
IplImage *arg2 = (IplImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
IplImage header2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_attach",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_attach" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
void * vptr;
int res = SWIG_ConvertPtr(obj1, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg2 = cvGetImage((CvMat *)vptr, &header2);
}
{
try {
(arg1)->attach(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_attach(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_attach__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p__IplImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvImage_attach__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvImage_attach'.\n"
" Possible C/C++ prototypes are:\n"
" attach(CvImage *,IplImage *,bool)\n"
" attach(CvImage *,IplImage *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_detach",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_detach" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
(arg1)->detach();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvImage_load",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_load" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvImage_load" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvImage_load",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_load" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_load",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
result = (bool)(arg1)->load((char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_load(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_load__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_load__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvImage_load__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvImage_load'.\n"
" Possible C/C++ prototypes are:\n"
" load(CvImage *,char const *,char const *,int)\n"
" load(CvImage *,char const *,char const *)\n"
" load(CvImage *,char const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvImage_read",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_read" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_read" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvImage_read" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
{
try {
result = (bool)(arg1)->read(arg2,(char const *)arg3,(char const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvImage_read",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_read" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_read" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvImage_read" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (bool)(arg1)->read(arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_read(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvImage_read__SWIG_1(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_read__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvImage_read'.\n"
" Possible C/C++ prototypes are:\n"
" read(CvImage *,CvFileStorage *,char const *,char const *)\n"
" read(CvImage *,CvFileStorage *,char const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvImage_save",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_save" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_save" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_save" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
(arg1)->save((char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvImage_write",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_write" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_write" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvImage_write" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
(arg1)->write(arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_show",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_show" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_show" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
(arg1)->show((char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_is_valid",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_is_valid" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (bool)(arg1)->is_valid();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_width",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_width" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->width();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_height",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_height" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->height();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_size" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = ((CvImage const *)arg1)->size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_roi_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_roi_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_size" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = ((CvImage const *)arg1)->roi_size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_roi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_roi",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = ((CvImage const *)arg1)->roi();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvRect(static_cast< const CvRect& >(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_coi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_coi",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_coi" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->coi();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_set_roi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
CvRect arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_set_roi",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_set_roi" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_set_roi" "', argument " "2"" of type '" "CvRect""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvImage_set_roi" "', argument " "2"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
try {
(arg1)->set_roi(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_reset_roi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_reset_roi",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_reset_roi" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
(arg1)->reset_roi();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_set_coi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_set_coi",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_set_coi" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_set_coi" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
(arg1)->set_coi(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_depth",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_depth" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->depth();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_channels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_channels",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_channels" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->channels();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_pix_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_pix_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_pix_size" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->pix_size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_data" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (uchar *)(arg1)->data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_data" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (uchar *)((CvImage const *)arg1)->data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_data(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[2];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_data__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvImage_data__SWIG_1(self, args);
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvImage_data'.\n"
" Possible C/C++ prototypes are:\n"
" data(CvImage *)\n"
" data(CvImage const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_step",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_step" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->step();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_origin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_origin",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_origin" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (int)((CvImage const *)arg1)->origin();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_roi_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_roi_row",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_row" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_roi_row" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (uchar *)(arg1)->roi_row(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_roi_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvImage_roi_row",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_row" "', argument " "1"" of type '" "CvImage const *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_roi_row" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (uchar *)((CvImage const *)arg1)->roi_row(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_roi_row(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvImage_roi_row__SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvImage_roi_row__SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvImage_roi_row'.\n"
" Possible C/C++ prototypes are:\n"
" roi_row(CvImage *,int)\n"
" roi_row(CvImage const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvImage_asIplImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvImage *arg1 = (CvImage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
IplImage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvImage_asIplImage",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvImage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_asIplImage" "', argument " "1"" of type '" "CvImage *""'");
}
arg1 = reinterpret_cast< CvImage * >(argp1);
{
try {
result = (IplImage *)(arg1)->operator IplImage*();
}
catch (...)
{
SWIG_fail;
}
}
{
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvImage, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMatrix")) SWIG_fail;
{
try {
result = (CvMatrix *)new CvMatrix();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvMatrix",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
void *arg5 = (void *) 0 ;
int arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int res5 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "void *""'");
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvMatrix" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
void *arg5 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int res5 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5), 0, 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "void *""'");
}
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMemStorage *arg4 = (CvMemStorage *) 0 ;
bool arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMemStorage *""'");
}
arg4 = reinterpret_cast< CvMemStorage * >(argp4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMemStorage *arg4 = (CvMemStorage *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMemStorage *""'");
}
arg4 = reinterpret_cast< CvMemStorage * >(argp4);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
void *arg4 = (void *) 0 ;
int arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "void *""'");
}
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
void *arg4 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int res4 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvMatrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "void *""'");
}
{
try {
result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvMatrix",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (CvMatrix *)new CvMatrix(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvMatrix",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvMatrix, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvMatrix const &""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvMatrix const &""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (CvMatrix *)new CvMatrix((CvMatrix const &)*arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvMatrix",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMatrix *)new CvMatrix((char const *)arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
char *arg2 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_CvMatrix",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
result = (CvMatrix *)new CvMatrix((char const *)arg1,(char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvMatrix",&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
try {
result = (CvMatrix *)new CvMatrix((char const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvMatrix",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,(char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFileStorage *arg1 = (CvFileStorage *) 0 ;
char *arg2 = (char *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMatrix *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvMatrix",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvFileStorage *""'");
}
arg1 = reinterpret_cast< CvFileStorage * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvMatrix *)new CvMatrix(arg1,(char const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, SWIG_POINTER_NEW | 0 );
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[7];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvMatrix__SWIG_0(self, args);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_9(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_10(self, args);
}
}
if (argc == 1) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_13(self, args);
}
}
if (argc == 2) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_12(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_15(self, args);
}
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_14(self, args);
}
}
}
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_1(self, args);
}
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_11(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_6(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_4(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_8(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMemStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_5(self, args);
}
}
}
}
}
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMatrix__SWIG_3(self, args);
}
}
}
}
}
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_7(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMatrix__SWIG_2(self, args);
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvMatrix'.\n"
" Possible C/C++ prototypes are:\n"
" CvMatrix()\n"
" CvMatrix(int,int,int)\n"
" CvMatrix(int,int,int,CvMat *,void *,int)\n"
" CvMatrix(int,int,int,CvMat *,void *)\n"
" CvMatrix(int,int,int,CvMat *)\n"
" CvMatrix(int,int,int,CvMemStorage *,bool)\n"
" CvMatrix(int,int,int,CvMemStorage *)\n"
" CvMatrix(int,int,int,void *,int)\n"
" CvMatrix(int,int,int,void *)\n"
" CvMatrix(CvMat *)\n"
" CvMatrix(CvMatrix const &)\n"
" CvMatrix(char const *,char const *,int)\n"
" CvMatrix(char const *,char const *)\n"
" CvMatrix(char const *)\n"
" CvMatrix(CvFileStorage *,char const *,char const *)\n"
" CvMatrix(CvFileStorage *,char const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMatrix",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatrix" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMatrix result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_clone",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_clone" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (arg1)->clone();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvMatrix(static_cast< const CvMatrix& >(result))), SWIGTYPE_p_CvMatrix, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
bool arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
bool val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMatrix_set",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
ecode3 = SWIG_AsVal_bool(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMatrix_set" "', argument " "3"" of type '" "bool""'");
}
arg3 = static_cast< bool >(val3);
{
try {
(arg1)->set(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvMatrix_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_create" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_create" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMatrix_create" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMatrix_create" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
(arg1)->create(arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_addref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_addref",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_addref" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
((CvMatrix const *)arg1)->addref();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_release",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_release" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
(arg1)->release();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_clear" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvMatrix_load",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_load" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMatrix_load" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMatrix_load",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_load" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix_load",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_load" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
result = (bool)(arg1)->load((char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_load(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_load__SWIG_2(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_load__SWIG_1(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMatrix_load__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMatrix_load'.\n"
" Possible C/C++ prototypes are:\n"
" load(CvMatrix *,char const *,char const *,int)\n"
" load(CvMatrix *,char const *,char const *)\n"
" load(CvMatrix *,char const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvMatrix_read",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_read" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_read" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvMatrix_read" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
{
try {
result = (bool)(arg1)->read(arg2,(char const *)arg3,(char const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvMatrix_read",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_read" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_read" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_read" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMatrix_read" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (bool)(arg1)->read(arg2,(char const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_read(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMatrix_read__SWIG_1(self, args);
}
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_read__SWIG_0(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMatrix_read'.\n"
" Possible C/C++ prototypes are:\n"
" read(CvMatrix *,CvFileStorage *,char const *,char const *)\n"
" read(CvMatrix *,CvFileStorage *,char const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMatrix_save",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_save" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_save" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_save" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
(arg1)->save((char const *)arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
CvFileStorage *arg2 = (CvFileStorage *) 0 ;
char *arg3 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMatrix_write",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_write" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_write" "', argument " "2"" of type '" "CvFileStorage *""'");
}
arg2 = reinterpret_cast< CvFileStorage * >(argp2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvMatrix_write" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
{
try {
(arg1)->write(arg2,(char const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return resultobj;
fail:
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_show(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
char *arg2 = (char *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix_show",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_show" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_show" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
{
try {
(arg1)->show((char const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_is_valid",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_is_valid" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (bool)(arg1)->is_valid();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_rows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_rows",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_rows" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->rows();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_cols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_cols",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_cols" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->cols();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_size" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = ((CvMatrix const *)arg1)->size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_type",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_type" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->type();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_depth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_depth",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_depth" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->depth();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_channels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_channels",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_channels" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->channels();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_pix_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_pix_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_pix_size" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->pix_size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_data" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (uchar *)(arg1)->data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_data",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_data" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (uchar *)((CvMatrix const *)arg1)->data();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_data(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[2];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 1); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_data__SWIG_0(self, args);
}
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_data__SWIG_1(self, args);
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMatrix_data'.\n"
" Possible C/C++ prototypes are:\n"
" data(CvMatrix *)\n"
" data(CvMatrix const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_step",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_step" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (int)((CvMatrix const *)arg1)->step();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_set_data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMatrix_set_data",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set_data" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set_data" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMatrix_set_data" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
(arg1)->set_data(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_set_data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *arg2 = (void *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix_set_data",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set_data" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set_data" "', argument " "2"" of type '" "void *""'");
}
{
try {
(arg1)->set_data(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_set_data(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMatrix_set_data__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMatrix_set_data__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMatrix_set_data'.\n"
" Possible C/C++ prototypes are:\n"
" set_data(CvMatrix *,void *,int)\n"
" set_data(CvMatrix *,void *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_row__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix_row",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_row" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_row" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (uchar *)(arg1)->row(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_row__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix_row",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_row" "', argument " "1"" of type '" "CvMatrix const *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_row" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (uchar *)((CvMatrix const *)arg1)->row(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_row(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMatrix_row__SWIG_0(self, args);
}
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMatrix_row__SWIG_1(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMatrix_row'.\n"
" Possible C/C++ prototypes are:\n"
" row(CvMatrix *,int)\n"
" row(CvMatrix const *,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix_asCvMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix *arg1 = (CvMatrix *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix_asCvMat",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_asCvMat" "', argument " "1"" of type '" "CvMatrix *""'");
}
arg1 = reinterpret_cast< CvMatrix * >(argp1);
{
try {
result = (CvMat *)(arg1)->operator CvMat*();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMatrix, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModuleInfo *arg1 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvModule *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:new_CvModule",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvModule" "', argument " "1"" of type '" "CvModuleInfo *""'");
}
arg1 = reinterpret_cast< CvModuleInfo * >(argp1);
{
try {
result = (CvModule *)new CvModule(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModule, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModule *arg1 = (CvModule *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvModule",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModule, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvModule" "', argument " "1"" of type '" "CvModule *""'");
}
arg1 = reinterpret_cast< CvModule * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModule_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModule *arg1 = (CvModule *) 0 ;
CvModuleInfo *arg2 = (CvModuleInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvModule_info_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModule, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModule_info_set" "', argument " "1"" of type '" "CvModule *""'");
}
arg1 = reinterpret_cast< CvModule * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModule_info_set" "', argument " "2"" of type '" "CvModuleInfo *""'");
}
arg2 = reinterpret_cast< CvModuleInfo * >(argp2);
if (arg1) (arg1)->info = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvModule_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvModule *arg1 = (CvModule *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvModuleInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvModule_info_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvModule, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModule_info_get" "', argument " "1"" of type '" "CvModule *""'");
}
arg1 = reinterpret_cast< CvModule * >(argp1);
result = (CvModuleInfo *) ((arg1)->info);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN int Swig_var_CvModule_first_set(PyObject *_val) {
{
void *argp = 0;
int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CvModuleInfo, 0 );
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvModule::first""' of type '""CvModuleInfo *""'");
}
CvModule::first = reinterpret_cast< CvModuleInfo * >(argp);
}
return 0;
fail:
return 1;
}
SWIGINTERN PyObject *Swig_var_CvModule_first_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(CvModule::first), SWIGTYPE_p_CvModuleInfo, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_CvModule_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
return Swig_var_CvModule_first_get();
}
SWIGINTERN PyObject *_wrap_CvModule_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *value;
int res;
if (!PyArg_ParseTuple(args,(char *)"O:set",&value)) return NULL;
res = Swig_var_CvModule_first_set(value);
return !res ? SWIG_Py_Void() : NULL;
}
SWIGINTERN int Swig_var_CvModule_last_set(PyObject *_val) {
{
void *argp = 0;
int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CvModuleInfo, 0 );
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvModule::last""' of type '""CvModuleInfo *""'");
}
CvModule::last = reinterpret_cast< CvModuleInfo * >(argp);
}
return 0;
fail:
return 1;
}
SWIGINTERN PyObject *Swig_var_CvModule_last_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(CvModule::last), SWIGTYPE_p_CvModuleInfo, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_CvModule_last_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
return Swig_var_CvModule_last_get();
}
SWIGINTERN PyObject *_wrap_CvModule_last_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *value;
int res;
if (!PyArg_ParseTuple(args,(char *)"O:set",&value)) return NULL;
res = Swig_var_CvModule_last_set(value);
return !res ? SWIG_Py_Void() : NULL;
}
SWIGINTERN PyObject *CvModule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvModule, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
CvReleaseFunc arg3 = (CvReleaseFunc) 0 ;
CvReadFunc arg4 = (CvReadFunc) 0 ;
CvWriteFunc arg5 = (CvWriteFunc) 0 ;
CvCloneFunc arg6 = (CvCloneFunc) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvType *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvType",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj4, (void**)(&arg5), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "5"" of type '" "CvWriteFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj5, (void**)(&arg6), SWIGTYPE_p_f_p_q_const__void__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "6"" of type '" "CvCloneFunc""'");
}
}
{
try {
result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
CvReleaseFunc arg3 = (CvReleaseFunc) 0 ;
CvReadFunc arg4 = (CvReadFunc) 0 ;
CvWriteFunc arg5 = (CvWriteFunc) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvType *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvType",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj4, (void**)(&arg5), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "5"" of type '" "CvWriteFunc""'");
}
}
{
try {
result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvType__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
CvReleaseFunc arg3 = (CvReleaseFunc) 0 ;
CvReadFunc arg4 = (CvReadFunc) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvType *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvType",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'");
}
}
{
try {
result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvType__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
CvReleaseFunc arg3 = (CvReleaseFunc) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvType *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvType",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
{
int res = SWIG_ConvertFunctionPtr(obj2, (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'");
}
}
{
try {
result = (CvType *)new CvType((char const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvType__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvType *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_CvType",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'");
}
}
{
try {
result = (CvType *)new CvType((char const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, SWIG_POINTER_NEW | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvType(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[7];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvType__SWIG_4(self, args);
}
}
}
if (argc == 3) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvType__SWIG_3(self, args);
}
}
}
}
if (argc == 4) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvType__SWIG_2(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvType__SWIG_1(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void);
_v = SWIG_CheckState(res);
if (_v) {
void *ptr = 0;
int res = SWIG_ConvertFunctionPtr(argv[5], &ptr, SWIGTYPE_p_f_p_q_const__void__p_void);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvType__SWIG_0(self, args);
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvType'.\n"
" Possible C/C++ prototypes are:\n"
" CvType(char const *,CvIsInstanceFunc,CvReleaseFunc,CvReadFunc,CvWriteFunc,CvCloneFunc)\n"
" CvType(char const *,CvIsInstanceFunc,CvReleaseFunc,CvReadFunc,CvWriteFunc)\n"
" CvType(char const *,CvIsInstanceFunc,CvReleaseFunc,CvReadFunc)\n"
" CvType(char const *,CvIsInstanceFunc,CvReleaseFunc)\n"
" CvType(char const *,CvIsInstanceFunc)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvType *arg1 = (CvType *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvType",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvType, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvType" "', argument " "1"" of type '" "CvType *""'");
}
arg1 = reinterpret_cast< CvType * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvType_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvType *arg1 = (CvType *) 0 ;
CvTypeInfo *arg2 = (CvTypeInfo *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvType_info_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvType, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvType_info_set" "', argument " "1"" of type '" "CvType *""'");
}
arg1 = reinterpret_cast< CvType * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvType_info_set" "', argument " "2"" of type '" "CvTypeInfo *""'");
}
arg2 = reinterpret_cast< CvTypeInfo * >(argp2);
if (arg1) (arg1)->info = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvType_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvType *arg1 = (CvType *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypeInfo *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvType_info_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvType, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvType_info_get" "', argument " "1"" of type '" "CvType *""'");
}
arg1 = reinterpret_cast< CvType * >(argp1);
result = (CvTypeInfo *) ((arg1)->info);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN int Swig_var_CvType_first_set(PyObject *_val) {
{
void *argp = 0;
int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CvTypeInfo, 0 );
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvType::first""' of type '""CvTypeInfo *""'");
}
CvType::first = reinterpret_cast< CvTypeInfo * >(argp);
}
return 0;
fail:
return 1;
}
SWIGINTERN PyObject *Swig_var_CvType_first_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(CvType::first), SWIGTYPE_p_CvTypeInfo, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_CvType_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
return Swig_var_CvType_first_get();
}
SWIGINTERN PyObject *_wrap_CvType_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *value;
int res;
if (!PyArg_ParseTuple(args,(char *)"O:set",&value)) return NULL;
res = Swig_var_CvType_first_set(value);
return !res ? SWIG_Py_Void() : NULL;
}
SWIGINTERN int Swig_var_CvType_last_set(PyObject *_val) {
{
void *argp = 0;
int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CvTypeInfo, 0 );
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvType::last""' of type '""CvTypeInfo *""'");
}
CvType::last = reinterpret_cast< CvTypeInfo * >(argp);
}
return 0;
fail:
return 1;
}
SWIGINTERN PyObject *Swig_var_CvType_last_get(void) {
PyObject *pyobj = 0;
pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(CvType::last), SWIGTYPE_p_CvTypeInfo, 0 );
return pyobj;
}
SWIGINTERN PyObject *_wrap_CvType_last_get(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(args)) {
return Swig_var_CvType_last_get();
}
SWIGINTERN PyObject *_wrap_CvType_last_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *value;
int res;
if (!PyArg_ParseTuple(args,(char *)"O:set",&value)) return NULL;
res = Swig_var_CvType_last_set(value);
return !res ? SWIG_Py_Void() : NULL;
}
SWIGINTERN PyObject *CvType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvType, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMoments_m00_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m00_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m00_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m00_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m00 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m00_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m00_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m00_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m00);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m10_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m10_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m10_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m10_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m10 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m10_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m10_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m10_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m10);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m01_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m01_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m01_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m01_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m01 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m01_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m01_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m01_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m01);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m20_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m20_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m20_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m20_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m20 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m20_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m20_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m20_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m20);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m11_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m11_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m11_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m11_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m11 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m11_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m11_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m11_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m11);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m02_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m02_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m02_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m02_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m02 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m02_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m02_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m02_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m02);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m30_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m30_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m30_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m30_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m30 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m30_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m30_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m30_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m30);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m21_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m21_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m21_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m21_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m21 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m21_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m21_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m21_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m21);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m12_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m12_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m12_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m12_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m12 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m12_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m12_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m12_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m12);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m03_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_m03_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m03_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m03_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->m03 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_m03_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_m03_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m03_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->m03);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu20_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu20_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu20_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu20_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu20 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu20_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu20_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu20_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu20);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu11_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu11_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu11_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu11_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu11 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu11_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu11_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu11_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu11);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu02_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu02_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu02_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu02_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu02 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu02_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu02_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu02_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu02);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu30_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu30_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu30_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu30_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu30 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu30_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu30_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu30_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu30);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu21_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu21_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu21_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu21_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu21 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu21_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu21_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu21_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu21);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu12_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu12_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu12_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu12_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu12 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu12_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu12_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu12_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu12);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu03_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_mu03_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu03_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu03_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->mu03 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_mu03_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_mu03_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu03_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->mu03);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_inv_sqrt_m00_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMoments_inv_sqrt_m00_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_inv_sqrt_m00_set" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_inv_sqrt_m00_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->inv_sqrt_m00 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMoments_inv_sqrt_m00_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMoments_inv_sqrt_m00_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_inv_sqrt_m00_get" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
result = (double) ((arg1)->inv_sqrt_m00);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMoments")) SWIG_fail;
{
try {
result = (CvMoments *)new CvMoments();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMoments, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMoments",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMoments" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMoments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMoments, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu1_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu1_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu1 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu1_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu1);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu2_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu2_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu2 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu2_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu2);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu3_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu3_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu3_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu3 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu3_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu3_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu3);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu4_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu4_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu4_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu4 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu4_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu4_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu4);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu5_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu5_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu5_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu5 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu5_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu5_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu5);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu6_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu6_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu6_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu6 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu6_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu6_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu6);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu7_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHuMoments_hu7_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu7_set" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu7_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hu7 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHuMoments_hu7_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHuMoments_hu7_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu7_get" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
result = (double) ((arg1)->hu7);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvHuMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvHuMoments")) SWIG_fail;
{
try {
result = (CvHuMoments *)new CvHuMoments();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHuMoments, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHuMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHuMoments *arg1 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHuMoments",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHuMoments, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHuMoments" "', argument " "1"" of type '" "CvHuMoments *""'");
}
arg1 = reinterpret_cast< CvHuMoments * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHuMoments_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHuMoments, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_area_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConnectedComp_area_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_area_set" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConnectedComp_area_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->area = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_area_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvConnectedComp_area_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_area_get" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
result = (double) ((arg1)->area);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
CvScalar *arg2 = (CvScalar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConnectedComp_value_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_value_set" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvScalar, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConnectedComp_value_set" "', argument " "2"" of type '" "CvScalar *""'");
}
arg2 = reinterpret_cast< CvScalar * >(argp2);
if (arg1) (arg1)->value = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvScalar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConnectedComp_value_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_value_get" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
result = (CvScalar *)& ((arg1)->value);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvScalar, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConnectedComp_rect_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_rect_set" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConnectedComp_rect_set" "', argument " "2"" of type '" "CvRect *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
if (arg1) (arg1)->rect = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConnectedComp_rect_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_rect_get" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
result = (CvRect *)& ((arg1)->rect);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_contour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConnectedComp_contour_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_contour_set" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->contour = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConnectedComp_contour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConnectedComp_contour_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_contour_get" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
result = (CvSeq *) ((arg1)->contour);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvConnectedComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvConnectedComp")) SWIG_fail;
{
try {
result = (CvConnectedComp *)new CvConnectedComp();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvConnectedComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConnectedComp *arg1 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvConnectedComp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConnectedComp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConnectedComp" "', argument " "1"" of type '" "CvConnectedComp *""'");
}
arg1 = reinterpret_cast< CvConnectedComp * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvConnectedComp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvConnectedComp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_header_size_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_header_size_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_seq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_seq_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_seq_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->seq = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_seq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_seq_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_seq_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (CvSeq *) ((arg1)->seq);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_block_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->block = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_block_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (CvSeqBlock *) ((arg1)->block);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_ptr_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_ptr_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_block_min_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_min_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_block_min_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_min = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_block_min_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_min_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (schar *) ((arg1)->block_min);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_max_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_max_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_delta_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_delta_index_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_delta_index_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_delta_index_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_index = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_delta_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_delta_index_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_delta_index_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (int) ((arg1)->delta_index);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_prev_elem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_prev_elem_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_prev_elem_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_prev_elem_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->prev_elem = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_prev_elem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_prev_elem_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_prev_elem_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (schar *) ((arg1)->prev_elem);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
char arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
char val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_code_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_code_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
ecode2 = SWIG_AsVal_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_code_set" "', argument " "2"" of type '" "char""'");
}
arg2 = static_cast< char >(val2);
if (arg1) (arg1)->code = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char result;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_code_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_code_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (char) ((arg1)->code);
resultobj = SWIG_From_char(static_cast< char >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_pt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_pt_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_pt_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_pt_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->pt = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_pt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_pt_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_pt_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (CvPoint *)& ((arg1)->pt);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_deltas_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
schar (*arg2)[2] ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvChainPtReader_deltas_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_deltas_set" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_2__signed_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_deltas_set" "', argument " "2"" of type '" "schar [8][2]""'");
}
arg2 = reinterpret_cast< schar (*)[2] >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)8; ++ii) {
if (arg2[ii]) {
size_t jj = 0;
for (; jj < (size_t)2; ++jj) arg1->deltas[ii][jj] = arg2[ii][jj];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""deltas""' of type '""schar [8][2]""'");
}
}
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""deltas""' of type '""schar [8][2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvChainPtReader_deltas_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar (*result)[2] = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvChainPtReader_deltas_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_deltas_get" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
result = (schar (*)[2])(schar (*)[2]) ((arg1)->deltas);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_2__signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvChainPtReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvChainPtReader")) SWIG_fail;
{
try {
result = (CvChainPtReader *)new CvChainPtReader();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvChainPtReader, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvChainPtReader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvChainPtReader",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvChainPtReader" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvChainPtReader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvChainPtReader, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvContourTree_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_flags_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_flags_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_header_size_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_header_size_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_h_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_prev_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_h_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_prev_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_h_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_next_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_h_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_next_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_v_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_prev_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_v_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_prev_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_v_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_next_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_v_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_next_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_total_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_total_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_total_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_total_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_elem_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_elem_size_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_elem_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_elem_size_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_block_max_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_block_max_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_ptr_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_ptr_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_delta_elems_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_delta_elems_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_delta_elems_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_delta_elems_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_storage_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_storage_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_storage_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_storage_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_free_blocks_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_free_blocks_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_free_blocks_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_free_blocks_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_first_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_first_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_p1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_p1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p1_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_p1_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->p1 = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_p1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_p1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p1_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvPoint *)& ((arg1)->p1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_p2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvContourTree_p2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p2_set" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_p2_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->p2 = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvContourTree_p2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvContourTree_p2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p2_get" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
result = (CvPoint *)& ((arg1)->p2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvContourTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvContourTree")) SWIG_fail;
{
try {
result = (CvContourTree *)new CvContourTree();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvContourTree, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvContourTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvContourTree",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvContourTree" "', argument " "1"" of type '" "CvContourTree *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvContourTree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvContourTree, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_start_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConvexityDefect_start_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_start_set" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_start_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->start = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_start_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConvexityDefect_start_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_start_get" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
result = (CvPoint *) ((arg1)->start);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_end_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConvexityDefect_end_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_end_set" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_end_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->end = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_end_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConvexityDefect_end_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_end_get" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
result = (CvPoint *) ((arg1)->end);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_depth_point_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConvexityDefect_depth_point_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_point_set" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_depth_point_set" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
if (arg1) (arg1)->depth_point = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_depth_point_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConvexityDefect_depth_point_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_point_get" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
result = (CvPoint *) ((arg1)->depth_point);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_depth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConvexityDefect_depth_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_set" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConvexityDefect_depth_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->depth = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConvexityDefect_depth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvConvexityDefect_depth_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_get" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
result = (float) ((arg1)->depth);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvConvexityDefect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvConvexityDefect")) SWIG_fail;
{
try {
result = (CvConvexityDefect *)new CvConvexityDefect();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConvexityDefect, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvConvexityDefect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvConvexityDefect",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConvexityDefect, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConvexityDefect" "', argument " "1"" of type '" "CvConvexityDefect *""'");
}
arg1 = reinterpret_cast< CvConvexityDefect * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvConvexityDefect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvConvexityDefect, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvQuadEdge2D_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_flags_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvQuadEdge2D_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvQuadEdge2D_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_flags_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_pt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
CvSubdiv2DPoint **arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvQuadEdge2D_pt_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_pt_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvQuadEdge2D_pt_set" "', argument " "2"" of type '" "CvSubdiv2DPoint *[4]""'");
}
arg2 = reinterpret_cast< CvSubdiv2DPoint ** >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4; ++ii) arg1->pt[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pt""' of type '""CvSubdiv2DPoint *[4]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_pt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DPoint **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvQuadEdge2D_pt_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_pt_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
result = (CvSubdiv2DPoint **)(CvSubdiv2DPoint **) ((arg1)->pt);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSubdiv2DPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
CvSubdiv2DEdge *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvQuadEdge2D_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_next_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_size_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvQuadEdge2D_next_set" "', argument " "2"" of type '" "CvSubdiv2DEdge [4]""'");
}
arg2 = reinterpret_cast< CvSubdiv2DEdge * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)4; ++ii) arg1->next[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""next""' of type '""CvSubdiv2DEdge [4]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvQuadEdge2D_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvQuadEdge2D_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_next_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
result = (CvSubdiv2DEdge *)(CvSubdiv2DEdge *) ((arg1)->next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_size_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvQuadEdge2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvQuadEdge2D")) SWIG_fail;
{
try {
result = (CvQuadEdge2D *)new CvQuadEdge2D();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvQuadEdge2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvQuadEdge2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvQuadEdge2D, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvQuadEdge2D" "', argument " "1"" of type '" "CvQuadEdge2D *""'");
}
arg1 = reinterpret_cast< CvQuadEdge2D * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvQuadEdge2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvQuadEdge2D, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2DPoint_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_flags_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2DPoint_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2DPoint_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_flags_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
CvSubdiv2DEdge arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
CvSubdiv2DEdge_Wrapper *wrapper2 ;
CvQuadEdge2D *qedge2 ;
void *vptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2DPoint_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_first_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper2 = (CvSubdiv2DEdge_Wrapper *) vptr2;
arg2 = wrapper2->ref();
}
else if( SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge2 = (CvQuadEdge2D *) vptr2;
arg2 = (CvSubdiv2DEdge)qedge2;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2DPoint_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_first_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
result = ((arg1)->first);
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_pt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2DPoint_pt_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_pt_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DPoint_pt_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->pt = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2DPoint_pt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2DPoint_pt_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_pt_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
result = (CvPoint2D32f *)& ((arg1)->pt);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSubdiv2DPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSubdiv2DPoint")) SWIG_fail;
{
try {
result = (CvSubdiv2DPoint *)new CvSubdiv2DPoint();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSubdiv2DPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSubdiv2DPoint",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2DPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2DPoint" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'");
}
arg1 = reinterpret_cast< CvSubdiv2DPoint * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSubdiv2DPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSubdiv2DPoint, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_flags_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_flags_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_header_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_header_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_header_size_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_header_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->header_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_header_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_header_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_header_size_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->header_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_h_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_h_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_prev_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_h_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_h_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_prev_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeq *) ((arg1)->h_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_h_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_h_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_next_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->h_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_h_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_h_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_next_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeq *) ((arg1)->h_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_v_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_v_prev_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_prev_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_prev = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_v_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_v_prev_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_prev_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeq *) ((arg1)->v_prev);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_v_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_v_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_next_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
if (arg1) (arg1)->v_next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_v_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_v_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_next_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeq *) ((arg1)->v_next);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_total_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_total_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_total_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_total_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->total = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_total_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_total_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_total_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->total);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_elem_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_elem_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_elem_size_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_elem_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->elem_size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_elem_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_elem_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_elem_size_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->elem_size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_block_max_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_block_max_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_block_max_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_block_max_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->block_max = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_block_max_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_block_max_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_block_max_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (schar *) ((arg1)->block_max);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_ptr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
schar *arg2 = (schar *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_ptr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_ptr_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_ptr_set" "', argument " "2"" of type '" "schar *""'");
}
arg2 = reinterpret_cast< schar * >(argp2);
if (arg1) (arg1)->ptr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_ptr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
schar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_ptr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_ptr_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (schar *) ((arg1)->ptr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_delta_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_delta_elems_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_delta_elems_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_delta_elems_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->delta_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_delta_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_delta_elems_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_delta_elems_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->delta_elems);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_storage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_storage_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_storage_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (arg1) (arg1)->storage = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_storage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMemStorage *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_storage_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_storage_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvMemStorage *) ((arg1)->storage);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_free_blocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_free_blocks_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_blocks_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->free_blocks = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_free_blocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_free_blocks_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_blocks_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeqBlock *) ((arg1)->free_blocks);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSeqBlock *arg2 = (CvSeqBlock *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_first_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_first_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'");
}
arg2 = reinterpret_cast< CvSeqBlock * >(argp2);
if (arg1) (arg1)->first = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeqBlock *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_first_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_first_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSeqBlock *) ((arg1)->first);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_free_elems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSetElem *arg2 = (CvSetElem *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_free_elems_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_elems_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'");
}
arg2 = reinterpret_cast< CvSetElem * >(argp2);
if (arg1) (arg1)->free_elems = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_free_elems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSetElem *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_free_elems_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_elems_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvSetElem *) ((arg1)->free_elems);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_active_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_active_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_active_count_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_active_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->active_count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_active_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_active_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_active_count_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->active_count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_quad_edges_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_quad_edges_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_quad_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_quad_edges_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->quad_edges = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_quad_edges_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_quad_edges_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_quad_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->quad_edges);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_is_geometry_valid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_is_geometry_valid_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_is_geometry_valid_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_is_geometry_valid_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->is_geometry_valid = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_is_geometry_valid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_is_geometry_valid_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_is_geometry_valid_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (int) ((arg1)->is_geometry_valid);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_recent_edge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvSubdiv2DEdge arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
CvSubdiv2DEdge_Wrapper *wrapper2 ;
CvQuadEdge2D *qedge2 ;
void *vptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_recent_edge_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_recent_edge_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
if( SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper2 = (CvSubdiv2DEdge_Wrapper *) vptr2;
arg2 = wrapper2->ref();
}
else if( SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge2 = (CvQuadEdge2D *) vptr2;
arg2 = (CvSubdiv2DEdge)qedge2;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
if (arg1) (arg1)->recent_edge = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_recent_edge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_recent_edge_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_recent_edge_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = ((arg1)->recent_edge);
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_topleft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_topleft_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_topleft_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_topleft_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->topleft = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_topleft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_topleft_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_topleft_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvPoint2D32f *)& ((arg1)->topleft);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_bottomright_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_bottomright_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_bottomright_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_bottomright_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->bottomright = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_bottomright_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_bottomright_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_bottomright_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
result = (CvPoint2D32f *)& ((arg1)->bottomright);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_edges_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvTypedSeq< CvQuadEdge2D > *arg2 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_edges_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_edges_set" "', argument " "2"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg2 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp2);
{
try {
CvSubdiv2D_typed_edges_set(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_edges_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvQuadEdge2D > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_edges_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
try {
result = (CvTypedSeq< CvQuadEdge2D > *)CvSubdiv2D_typed_edges_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_typed_edges_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvQuadEdge2D > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSubdiv2D_typed_edges_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_typed_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
try {
result = (CvTypedSeq< CvQuadEdge2D > *)CvSubdiv2D_typed_edges_get(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSubdiv2D_typed_edges_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvTypedSeq< CvQuadEdge2D > *arg2 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSubdiv2D_typed_edges_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_typed_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_typed_edges_set" "', argument " "2"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg2 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp2);
{
try {
CvSubdiv2D_typed_edges_set(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSubdiv2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSubdiv2D")) SWIG_fail;
{
try {
result = (CvSubdiv2D *)new CvSubdiv2D();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2D, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSubdiv2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSubdiv2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2D" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSubdiv2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSubdiv2D, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvMatrix3_m_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix3 *arg1 = (CvMatrix3 *) 0 ;
float (*arg2)[3] ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMatrix3_m_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix3, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix3_m_set" "', argument " "1"" of type '" "CvMatrix3 *""'");
}
arg1 = reinterpret_cast< CvMatrix3 * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_3__float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix3_m_set" "', argument " "2"" of type '" "float [3][3]""'");
}
arg2 = reinterpret_cast< float (*)[3] >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)3; ++ii) {
if (arg2[ii]) {
size_t jj = 0;
for (; jj < (size_t)3; ++jj) arg1->m[ii][jj] = arg2[ii][jj];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""m""' of type '""float [3][3]""'");
}
}
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""m""' of type '""float [3][3]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMatrix3_m_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix3 *arg1 = (CvMatrix3 *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float (*result)[3] = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMatrix3_m_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix3, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix3_m_get" "', argument " "1"" of type '" "CvMatrix3 *""'");
}
arg1 = reinterpret_cast< CvMatrix3 * >(argp1);
result = (float (*)[3])(float (*)[3]) ((arg1)->m);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMatrix3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix3 *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMatrix3")) SWIG_fail;
{
try {
result = (CvMatrix3 *)new CvMatrix3();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix3, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMatrix3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMatrix3 *arg1 = (CvMatrix3 *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMatrix3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMatrix3, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatrix3" "', argument " "1"" of type '" "CvMatrix3 *""'");
}
arg1 = reinterpret_cast< CvMatrix3 * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvMatrix3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMatrix3, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvConDensation_MP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_MP_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_MP_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_MP_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->MP = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_MP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_MP_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_MP_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (int) ((arg1)->MP);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_DP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_DP_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DP_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_DP_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->DP = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_DP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_DP_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DP_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (int) ((arg1)->DP);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_DynamMatr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_DynamMatr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DynamMatr_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_DynamMatr_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->DynamMatr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_DynamMatr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_DynamMatr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DynamMatr_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->DynamMatr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_State_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_State_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_State_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_State_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->State = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_State_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_State_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_State_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->State);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_SamplesNum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_SamplesNum_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_SamplesNum_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_SamplesNum_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->SamplesNum = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_SamplesNum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_SamplesNum_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_SamplesNum_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (int) ((arg1)->SamplesNum);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flSamples_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float **arg2 = (float **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
float *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_flSamples_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flSamples_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_float, 1)) == -1){
SWIG_fail;
}
buffer2 = (float *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->flSamples = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flSamples_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_flSamples_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flSamples_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float **) ((arg1)->flSamples);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flNewSamples_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float **arg2 = (float **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
float *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_flNewSamples_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flNewSamples_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_float, 1)) == -1){
SWIG_fail;
}
buffer2 = (float *) vptr2;
arg2=&buffer2;
}
if (arg1) (arg1)->flNewSamples = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flNewSamples_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_flNewSamples_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flNewSamples_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float **) ((arg1)->flNewSamples);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flConfidence_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_flConfidence_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flConfidence_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_flConfidence_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->flConfidence = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flConfidence_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_flConfidence_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flConfidence_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->flConfidence);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flCumulative_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_flCumulative_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flCumulative_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_flCumulative_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->flCumulative = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_flCumulative_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_flCumulative_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flCumulative_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->flCumulative);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_Temp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_Temp_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_Temp_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_Temp_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->Temp = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_Temp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_Temp_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_Temp_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->Temp);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_RandomSample_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_RandomSample_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandomSample_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_RandomSample_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->RandomSample = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_RandomSample_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_RandomSample_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandomSample_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (float *) ((arg1)->RandomSample);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_RandS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
CvRandState *arg2 = (CvRandState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvConDensation_RandS_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandS_set" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRandState, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_RandS_set" "', argument " "2"" of type '" "CvRandState *""'");
}
arg2 = reinterpret_cast< CvRandState * >(argp2);
if (arg1) (arg1)->RandS = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvConDensation_RandS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRandState *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvConDensation_RandS_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandS_get" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
result = (CvRandState *) ((arg1)->RandS);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRandState, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvConDensation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvConDensation",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConDensation" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
{
try {
delete_CvConDensation(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvConDensation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvConDensation, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvKalman_MP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_MP_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MP_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_MP_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->MP = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_MP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_MP_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MP_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (int) ((arg1)->MP);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_DP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_DP_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DP_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_DP_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->DP = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_DP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_DP_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DP_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (int) ((arg1)->DP);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_CP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_CP_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_CP_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_CP_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->CP = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_CP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_CP_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_CP_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (int) ((arg1)->CP);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PosterState_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_PosterState_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterState_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_PosterState_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->PosterState = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PosterState_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_PosterState_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterState_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->PosterState);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PriorState_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_PriorState_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorState_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_PriorState_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->PriorState = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PriorState_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_PriorState_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorState_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->PriorState);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_DynamMatr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_DynamMatr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DynamMatr_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_DynamMatr_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->DynamMatr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_DynamMatr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_DynamMatr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DynamMatr_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->DynamMatr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_MeasurementMatr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_MeasurementMatr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MeasurementMatr_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_MeasurementMatr_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->MeasurementMatr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_MeasurementMatr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_MeasurementMatr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MeasurementMatr_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->MeasurementMatr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_MNCovariance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_MNCovariance_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MNCovariance_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_MNCovariance_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->MNCovariance = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_MNCovariance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_MNCovariance_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MNCovariance_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->MNCovariance);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PNCovariance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_PNCovariance_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PNCovariance_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_PNCovariance_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->PNCovariance = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PNCovariance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_PNCovariance_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PNCovariance_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->PNCovariance);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_KalmGainMatr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_KalmGainMatr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_KalmGainMatr_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_KalmGainMatr_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->KalmGainMatr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_KalmGainMatr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_KalmGainMatr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_KalmGainMatr_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->KalmGainMatr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PriorErrorCovariance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_PriorErrorCovariance_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorErrorCovariance_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_PriorErrorCovariance_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->PriorErrorCovariance = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PriorErrorCovariance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_PriorErrorCovariance_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorErrorCovariance_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->PriorErrorCovariance);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PosterErrorCovariance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_PosterErrorCovariance_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterErrorCovariance_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_PosterErrorCovariance_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->PosterErrorCovariance = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_PosterErrorCovariance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_PosterErrorCovariance_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterErrorCovariance_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->PosterErrorCovariance);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_Temp1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_Temp1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp1_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_Temp1_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->Temp1 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_Temp1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_Temp1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp1_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->Temp1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_Temp2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_Temp2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp2_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_Temp2_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->Temp2 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_Temp2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_Temp2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp2_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (float *) ((arg1)->Temp2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_state_pre_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_state_pre_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_pre_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_state_pre_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->state_pre = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_state_pre_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_state_pre_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_pre_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->state_pre);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_state_post_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_state_post_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_post_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_state_post_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->state_post = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_state_post_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_state_post_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_post_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->state_post);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_transition_matrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_transition_matrix_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_transition_matrix_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_transition_matrix_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->transition_matrix = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_transition_matrix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_transition_matrix_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_transition_matrix_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->transition_matrix);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_control_matrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_control_matrix_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_control_matrix_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_control_matrix_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->control_matrix = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_control_matrix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_control_matrix_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_control_matrix_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->control_matrix);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_measurement_matrix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_measurement_matrix_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_matrix_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_measurement_matrix_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->measurement_matrix = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_measurement_matrix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_measurement_matrix_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_matrix_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->measurement_matrix);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_process_noise_cov_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_process_noise_cov_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_process_noise_cov_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_process_noise_cov_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->process_noise_cov = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_process_noise_cov_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_process_noise_cov_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_process_noise_cov_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->process_noise_cov);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_measurement_noise_cov_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_measurement_noise_cov_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_noise_cov_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_measurement_noise_cov_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->measurement_noise_cov = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_measurement_noise_cov_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_measurement_noise_cov_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_noise_cov_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->measurement_noise_cov);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_error_cov_pre_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_error_cov_pre_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_pre_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_error_cov_pre_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->error_cov_pre = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_error_cov_pre_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_error_cov_pre_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_pre_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->error_cov_pre);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_gain_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_gain_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_gain_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_gain_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->gain = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_gain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_gain_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_gain_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->gain);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_error_cov_post_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_error_cov_post_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_post_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_error_cov_post_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->error_cov_post = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_error_cov_post_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_error_cov_post_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_post_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->error_cov_post);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_temp1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp1_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_temp1_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->temp1 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_temp1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp1_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->temp1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_temp2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp2_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_temp2_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->temp2 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_temp2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp2_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->temp2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_temp3_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp3_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_temp3_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->temp3 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_temp3_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp3_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->temp3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_temp4_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp4_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_temp4_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->temp4 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_temp4_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp4_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->temp4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvKalman_temp5_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp5_set" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKalman_temp5_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->temp5 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvKalman_temp5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvKalman_temp5_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp5_get" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
result = (CvMat *) ((arg1)->temp5);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvKalman(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvKalman",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvKalman" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
{
try {
delete_CvKalman(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvKalman_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvKalman, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_tilted_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature *arg1 = (CvHaarFeature *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarFeature_tilted_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_tilted_set" "', argument " "1"" of type '" "CvHaarFeature *""'");
}
arg1 = reinterpret_cast< CvHaarFeature * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarFeature_tilted_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->tilted = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_tilted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature *arg1 = (CvHaarFeature *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarFeature_tilted_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_tilted_get" "', argument " "1"" of type '" "CvHaarFeature *""'");
}
arg1 = reinterpret_cast< CvHaarFeature * >(argp1);
result = (int) ((arg1)->tilted);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature *arg1 = (CvHaarFeature *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvHaarFeature_rect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarFeature_rect_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_get" "', argument " "1"" of type '" "CvHaarFeature *""'");
}
arg1 = reinterpret_cast< CvHaarFeature * >(argp1);
result = (CvHaarFeature_rect *)(CvHaarFeature_rect *) ((arg1)->rect);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvHaarFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvHaarFeature")) SWIG_fail;
{
try {
result = (CvHaarFeature *)new CvHaarFeature();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHaarFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature *arg1 = (CvHaarFeature *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHaarFeature",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarFeature" "', argument " "1"" of type '" "CvHaarFeature *""'");
}
arg1 = reinterpret_cast< CvHaarFeature * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHaarFeature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHaarFeature, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_rect_r_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarFeature_rect_r_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_r_set" "', argument " "1"" of type '" "CvHaarFeature_rect *""'");
}
arg1 = reinterpret_cast< CvHaarFeature_rect * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarFeature_rect_r_set" "', argument " "2"" of type '" "CvRect *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
if (arg1) (arg1)->r = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_rect_r_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarFeature_rect_r_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_r_get" "', argument " "1"" of type '" "CvHaarFeature_rect *""'");
}
arg1 = reinterpret_cast< CvHaarFeature_rect * >(argp1);
result = (CvRect *)& ((arg1)->r);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_rect_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarFeature_rect_weight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_weight_set" "', argument " "1"" of type '" "CvHaarFeature_rect *""'");
}
arg1 = reinterpret_cast< CvHaarFeature_rect * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarFeature_rect_weight_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->weight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarFeature_rect_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarFeature_rect_weight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_weight_get" "', argument " "1"" of type '" "CvHaarFeature_rect *""'");
}
arg1 = reinterpret_cast< CvHaarFeature_rect * >(argp1);
result = (float) ((arg1)->weight);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvHaarFeature_rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvHaarFeature_rect")) SWIG_fail;
{
try {
result = (CvHaarFeature_rect *)new CvHaarFeature_rect();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature_rect, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHaarFeature_rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHaarFeature_rect",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarFeature_rect, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarFeature_rect" "', argument " "1"" of type '" "CvHaarFeature_rect *""'");
}
arg1 = reinterpret_cast< CvHaarFeature_rect * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHaarFeature_rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHaarFeature_rect, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_count_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifier_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_count_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (int) ((arg1)->count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_haar_feature_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
CvHaarFeature *arg2 = (CvHaarFeature *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_haar_feature_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_haar_feature_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarFeature, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_haar_feature_set" "', argument " "2"" of type '" "CvHaarFeature *""'");
}
arg2 = reinterpret_cast< CvHaarFeature * >(argp2);
if (arg1) (arg1)->haar_feature = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_haar_feature_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvHaarFeature *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_haar_feature_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_haar_feature_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (CvHaarFeature *) ((arg1)->haar_feature);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_threshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_threshold_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_threshold_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_threshold_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->threshold = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_threshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_threshold_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_threshold_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (float *) ((arg1)->threshold);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_left_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_left_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_left_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_left_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->left = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_left_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_left_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (int *) ((arg1)->left);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_right_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
int *arg2 = (int *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_right_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_right_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_right_set" "', argument " "2"" of type '" "int *""'");
}
arg2 = reinterpret_cast< int * >(argp2);
if (arg1) (arg1)->right = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_right_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_right_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (int *) ((arg1)->right);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_alpha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
float *arg2 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifier_alpha_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_alpha_set" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_alpha_set" "', argument " "2"" of type '" "float *""'");
}
arg2 = reinterpret_cast< float * >(argp2);
if (arg1) (arg1)->alpha = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifier_alpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifier_alpha_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_alpha_get" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
result = (float *) ((arg1)->alpha);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvHaarClassifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvHaarClassifier")) SWIG_fail;
{
try {
result = (CvHaarClassifier *)new CvHaarClassifier();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarClassifier, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHaarClassifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHaarClassifier",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifier, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarClassifier" "', argument " "1"" of type '" "CvHaarClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarClassifier * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHaarClassifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHaarClassifier, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_count_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_count_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (int) ((arg1)->count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_threshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_threshold_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_threshold_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_threshold_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->threshold = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_threshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_threshold_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_threshold_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (float) ((arg1)->threshold);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_classifier_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
CvHaarClassifier *arg2 = (CvHaarClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_classifier_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_classifier_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarClassifier, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarStageClassifier_classifier_set" "', argument " "2"" of type '" "CvHaarClassifier *""'");
}
arg2 = reinterpret_cast< CvHaarClassifier * >(argp2);
if (arg1) (arg1)->classifier = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_classifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvHaarClassifier *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_classifier_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_classifier_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (CvHaarClassifier *) ((arg1)->classifier);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarClassifier, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_next_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_next_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_next_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->next = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_next_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_next_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (int) ((arg1)->next);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_child_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_child_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_child_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_child_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->child = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_child_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_child_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_child_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (int) ((arg1)->child);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_parent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarStageClassifier_parent_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_parent_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_parent_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->parent = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarStageClassifier_parent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarStageClassifier_parent_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_parent_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
result = (int) ((arg1)->parent);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvHaarStageClassifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvHaarStageClassifier")) SWIG_fail;
{
try {
result = (CvHaarStageClassifier *)new CvHaarStageClassifier();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarStageClassifier, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHaarStageClassifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHaarStageClassifier",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarStageClassifier, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarStageClassifier" "', argument " "1"" of type '" "CvHaarStageClassifier *""'");
}
arg1 = reinterpret_cast< CvHaarStageClassifier * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHaarStageClassifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHaarStageClassifier, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_flags_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_flags_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_flags_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->flags = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_flags_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_flags_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (int) ((arg1)->flags);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_count_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_count_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_count_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->count = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_count_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_count_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (int) ((arg1)->count);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_orig_window_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvSize *arg2 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_orig_window_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_orig_window_size_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_orig_window_size_set" "', argument " "2"" of type '" "CvSize *""'");
}
arg2 = reinterpret_cast< CvSize * >(argp2);
if (arg1) (arg1)->orig_window_size = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_orig_window_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_orig_window_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_orig_window_size_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (CvSize *)& ((arg1)->orig_window_size);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_real_window_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvSize *arg2 = (CvSize *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_real_window_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_real_window_size_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_real_window_size_set" "', argument " "2"" of type '" "CvSize *""'");
}
arg2 = reinterpret_cast< CvSize * >(argp2);
if (arg1) (arg1)->real_window_size = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_real_window_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_real_window_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_real_window_size_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (CvSize *)& ((arg1)->real_window_size);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_scale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_scale_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_scale_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_scale_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->scale = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_scale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_scale_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_scale_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (double) ((arg1)->scale);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_stage_classifier_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvHaarStageClassifier *arg2 = (CvHaarStageClassifier *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_stage_classifier_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_stage_classifier_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHaarStageClassifier, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_stage_classifier_set" "', argument " "2"" of type '" "CvHaarStageClassifier *""'");
}
arg2 = reinterpret_cast< CvHaarStageClassifier * >(argp2);
if (arg1) (arg1)->stage_classifier = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_stage_classifier_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvHaarStageClassifier *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_stage_classifier_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_stage_classifier_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (CvHaarStageClassifier *) ((arg1)->stage_classifier);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_hid_cascade_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvHidHaarClassifierCascade *arg2 = (CvHidHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvHaarClassifierCascade_hid_cascade_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_hid_cascade_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHidHaarClassifierCascade, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_hid_cascade_set" "', argument " "2"" of type '" "CvHidHaarClassifierCascade *""'");
}
arg2 = reinterpret_cast< CvHidHaarClassifierCascade * >(argp2);
if (arg1) (arg1)->hid_cascade = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvHaarClassifierCascade_hid_cascade_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvHidHaarClassifierCascade *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvHaarClassifierCascade_hid_cascade_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_hid_cascade_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
result = (CvHidHaarClassifierCascade *) ((arg1)->hid_cascade);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHidHaarClassifierCascade, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvHaarClassifierCascade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvHaarClassifierCascade",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarClassifierCascade" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
{
try {
delete_CvHaarClassifierCascade(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvHaarClassifierCascade_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvHaarClassifierCascade, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvAvgComp_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *arg1 = (CvAvgComp *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvAvgComp_rect_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_rect_set" "', argument " "1"" of type '" "CvAvgComp *""'");
}
arg1 = reinterpret_cast< CvAvgComp * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvAvgComp_rect_set" "', argument " "2"" of type '" "CvRect *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
if (arg1) (arg1)->rect = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAvgComp_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *arg1 = (CvAvgComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvAvgComp_rect_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_rect_get" "', argument " "1"" of type '" "CvAvgComp *""'");
}
arg1 = reinterpret_cast< CvAvgComp * >(argp1);
result = (CvRect *)& ((arg1)->rect);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAvgComp_neighbors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *arg1 = (CvAvgComp *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvAvgComp_neighbors_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_neighbors_set" "', argument " "1"" of type '" "CvAvgComp *""'");
}
arg1 = reinterpret_cast< CvAvgComp * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvAvgComp_neighbors_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->neighbors = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvAvgComp_neighbors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *arg1 = (CvAvgComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvAvgComp_neighbors_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_neighbors_get" "', argument " "1"" of type '" "CvAvgComp *""'");
}
arg1 = reinterpret_cast< CvAvgComp * >(argp1);
result = (int) ((arg1)->neighbors);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvAvgComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvAvgComp")) SWIG_fail;
{
try {
result = (CvAvgComp *)new CvAvgComp();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAvgComp, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvAvgComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvAvgComp *arg1 = (CvAvgComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvAvgComp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvAvgComp, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvAvgComp" "', argument " "1"" of type '" "CvAvgComp *""'");
}
arg1 = reinterpret_cast< CvAvgComp * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvAvgComp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvAvgComp, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvCopyMakeBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvPoint arg3 ;
int arg4 ;
CvScalar arg5 = (CvScalar) cvScalarAll(0) ;
bool freearg1 = false ;
bool freearg2 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvCopyMakeBorder",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvPoint(obj2);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCopyMakeBorder" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj4) {
{
arg5 = PyObject_to_CvScalar( obj4 );
}
}
{
try {
cvCopyMakeBorder((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSmooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 2 ;
int arg4 = (int) 3 ;
int arg5 = (int) 0 ;
double arg6 = (double) 0 ;
double arg7 = (double) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOOO:cvSmooth",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSmooth" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSmooth" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSmooth" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvSmooth" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvSmooth" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
{
try {
cvSmooth((void const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFilter2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvPoint arg4 = (CvPoint) cvPoint(-1,-1) ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvFilter2D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFilter2D" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
{
arg4 = PyObject_to_CvPoint(obj3);
}
}
{
try {
cvFilter2D((void const *)arg1,arg2,(CvMat const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvIntegral(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) NULL ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvIntegral",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvIntegral((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPyrDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) CV_GAUSSIAN_5x5 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvPyrDown",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPyrDown" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvPyrDown((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPyrUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) CV_GAUSSIAN_5x5 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvPyrUp",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPyrUp" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvPyrUp((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreatePyramid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
double arg3 ;
CvSize *arg4 = (CvSize *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
int arg6 = (int) 1 ;
int arg7 = (int) CV_GAUSSIAN_5x5 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
bool freearg5 = false ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvMat **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOO:cvCreatePyramid",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreatePyramid" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreatePyramid" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvSize, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCreatePyramid" "', argument " "4"" of type '" "CvSize const *""'");
}
arg4 = reinterpret_cast< CvSize * >(argp4);
}
if (obj4) {
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCreatePyramid" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvCreatePyramid" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
{
try {
result = (CvMat **)cvCreatePyramid((void const *)arg1,arg2,arg3,(CvSize const *)arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvMat, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleasePyramid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat ***arg1 = (CvMat ***) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvReleasePyramid",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReleasePyramid" "', argument " "1"" of type '" "CvMat ***""'");
}
arg1 = reinterpret_cast< CvMat *** >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvReleasePyramid" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
cvReleasePyramid(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPyrSegmentationUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage *arg1 = (IplImage *) 0 ;
IplImage *arg2 = (IplImage *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) 0 ;
CvSeq **arg4 = (CvSeq **) 0 ;
int arg5 ;
double arg6 ;
double arg7 ;
IplImage header1 ;
IplImage header2 ;
void *argp3 = 0 ;
int res3 = 0 ;
CvSeq *seq4 ;
int val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
{
arg4 = &seq4;
}
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvPyrSegmentationUntyped",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
void * vptr;
int res = SWIG_ConvertPtr(obj0, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg1 = cvGetImage((CvMat *)vptr, &header1);
}
{
void * vptr;
int res = SWIG_ConvertPtr(obj1, (&vptr), SWIGTYPE_p_CvMat, 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
arg2 = cvGetImage((CvMat *)vptr, &header2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvPyrSegmentationUntyped" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvPyrSegmentationUntyped" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_double(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvPyrSegmentationUntyped" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
ecode7 = SWIG_AsVal_double(obj5, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvPyrSegmentationUntyped" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
{
try {
cvPyrSegmentation(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
PyObject *to_add;
/* extract the pointer we want to add to the returned tuple */
/* sequence is allocated in CvMemStorage, so python_ownership=0 */
to_add = SWIG_NewPointerObj (*arg4, SWIGTYPE_p_CvSeq, 0);
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPyrMeanShiftFiltering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
double arg4 ;
int arg5 = (int) 1 ;
CvTermCriteria arg6 = (CvTermCriteria) cvTermCriteria(1 +2,5,1) ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvPyrMeanShiftFiltering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPyrMeanShiftFiltering" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvPyrMeanShiftFiltering" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvPyrMeanShiftFiltering" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvPyrMeanShiftFiltering" "', argument " "6"" of type '" "CvTermCriteria""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvPyrMeanShiftFiltering" "', argument " "6"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
}
{
try {
cvPyrMeanShiftFiltering((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWatershed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvWatershed",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvWatershed((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInpaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 ;
int arg5 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvInpaint",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvInpaint" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvInpaint" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
cvInpaint((void const *)arg1,(void const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSobel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
int arg4 ;
int arg5 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvSobel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSobel" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSobel" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSobel" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvSobel((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLaplace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvLaplace",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvLaplace" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvLaplace((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCvtColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCvtColor",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCvtColor" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
cvCvtColor((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvResize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvResize",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvResize" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvResize((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWarpAffine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
int arg4 = (int) 1+8 ;
CvScalar arg5 = (CvScalar) cvScalarAll(0) ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvWarpAffine",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvWarpAffine" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvWarpAffine" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
{
arg5 = PyObject_to_CvScalar( obj4 );
}
}
{
try {
cvWarpAffine((void const *)arg1,arg2,(CvMat const *)arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetAffineTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetAffineTransform",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetAffineTransform" "', argument " "1"" of type '" "CvPoint2D32f const *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetAffineTransform" "', argument " "2"" of type '" "CvPoint2D32f const *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetAffineTransform" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
result = (CvMat *)cvGetAffineTransform((CvPoint2D32f const *)arg1,(CvPoint2D32f const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cv2DRotationMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f arg1 ;
double arg2 ;
double arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
double val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cv2DRotationMatrix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint2D32f(obj0);
}
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cv2DRotationMatrix" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cv2DRotationMatrix" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cv2DRotationMatrix" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
result = (CvMat *)cv2DRotationMatrix(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvWarpPerspective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
int arg4 = (int) 1+8 ;
CvScalar arg5 = (CvScalar) cvScalarAll(0) ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvWarpPerspective",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvWarpPerspective" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvWarpPerspective" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
{
arg5 = PyObject_to_CvScalar( obj4 );
}
}
{
try {
cvWarpPerspective((void const *)arg1,arg2,(CvMat const *)arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetPerspectiveTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetPerspectiveTransform",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetPerspectiveTransform" "', argument " "1"" of type '" "CvPoint2D32f const *""'");
}
arg1 = reinterpret_cast< CvPoint2D32f * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetPerspectiveTransform" "', argument " "2"" of type '" "CvPoint2D32f const *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetPerspectiveTransform" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
result = (CvMat *)cvGetPerspectiveTransform((CvPoint2D32f const *)arg1,(CvPoint2D32f const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRemap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
int arg5 = (int) 1+8 ;
CvScalar arg6 = (CvScalar) cvScalarAll(0) ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvRemap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvRemap" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
{
arg6 = PyObject_to_CvScalar( obj5 );
}
}
{
try {
cvRemap((void const *)arg1,arg2,(void const *)arg3,(void const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvertMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvConvertMaps",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvConvertMaps((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLogPolar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvPoint2D32f arg3 ;
double arg4 ;
int arg5 = (int) 1+8 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvLogPolar",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvPoint2D32f(obj2);
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvLogPolar" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvLogPolar" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvLogPolar((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateStructuringElementEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
int *arg6 = (int *) NULL ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
IplConvKernel *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvCreateStructuringElementEx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateStructuringElementEx" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateStructuringElementEx" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateStructuringElementEx" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCreateStructuringElementEx" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCreateStructuringElementEx" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvCreateStructuringElementEx" "', argument " "6"" of type '" "int *""'");
}
arg6 = reinterpret_cast< int * >(argp6);
}
{
try {
result = (IplConvKernel *)cvCreateStructuringElementEx(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplConvKernel, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvErode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplConvKernel *arg3 = (IplConvKernel *) NULL ;
int arg4 = (int) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvErode",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvErode" "', argument " "3"" of type '" "IplConvKernel *""'");
}
arg3 = reinterpret_cast< IplConvKernel * >(argp3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvErode" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvErode((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDilate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
IplConvKernel *arg3 = (IplConvKernel *) NULL ;
int arg4 = (int) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvDilate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvDilate" "', argument " "3"" of type '" "IplConvKernel *""'");
}
arg3 = reinterpret_cast< IplConvKernel * >(argp3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvDilate" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvDilate((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMorphologyEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
IplConvKernel *arg4 = (IplConvKernel *) 0 ;
int arg5 ;
int arg6 = (int) 1 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
void *argp4 = 0 ;
int res4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvMorphologyEx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p__IplConvKernel, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMorphologyEx" "', argument " "4"" of type '" "IplConvKernel *""'");
}
arg4 = reinterpret_cast< IplConvKernel * >(argp4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvMorphologyEx" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvMorphologyEx" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvMorphologyEx((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMoments *arg2 = (CvMoments *) 0 ;
int arg3 = (int) 0 ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvMoments",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMoments" "', argument " "2"" of type '" "CvMoments *""'");
}
arg2 = reinterpret_cast< CvMoments * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMoments" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvMoments((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetSpatialMoment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetSpatialMoment",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetSpatialMoment" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetSpatialMoment" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetSpatialMoment" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvGetSpatialMoment(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetCentralMoment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetCentralMoment",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetCentralMoment" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetCentralMoment" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetCentralMoment" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvGetCentralMoment(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetNormalizedCentralMoment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetNormalizedCentralMoment",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetNormalizedCentralMoment" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetNormalizedCentralMoment" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetNormalizedCentralMoment" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvGetNormalizedCentralMoment(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetHuMoments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMoments *arg1 = (CvMoments *) 0 ;
CvHuMoments *arg2 = (CvHuMoments *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvGetHuMoments",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMoments, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetHuMoments" "', argument " "1"" of type '" "CvMoments *""'");
}
arg1 = reinterpret_cast< CvMoments * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHuMoments, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGetHuMoments" "', argument " "2"" of type '" "CvHuMoments *""'");
}
arg2 = reinterpret_cast< CvHuMoments * >(argp2);
{
try {
cvGetHuMoments(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSampleLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvPoint arg3 ;
void *arg4 = (void *) 0 ;
int arg5 = (int) 8 ;
bool freearg1 = false ;
int res4 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvSampleLine",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
arg3 = PyObject_to_CvPoint(obj2);
}
res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4), 0, 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvSampleLine" "', argument " "4"" of type '" "void *""'");
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSampleLine" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
result = (int)cvSampleLine((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetRectSubPix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvPoint2D32f arg3 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetRectSubPix",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvPoint2D32f(obj2);
}
{
try {
cvGetRectSubPix((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetQuadrangleSubPix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvGetQuadrangleSubPix",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvGetQuadrangleSubPix" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
cvGetQuadrangleSubPix((void const *)arg1,arg2,(CvMat const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMatchTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
int arg4 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMatchTemplate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMatchTemplate" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
cvMatchTemplate((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcEMD2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
CvDistanceFunction arg4 = (CvDistanceFunction) NULL ;
CvArr *arg5 = (CvArr *) NULL ;
CvArr *arg6 = (CvArr *) NULL ;
float *arg7 = (float *) NULL ;
void *arg8 = (void *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
bool freearg5 = false ;
bool freearg6 = false ;
void *argp7 = 0 ;
int res7 = 0 ;
int res8 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOOO:cvCalcEMD2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCalcEMD2" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
{
int res = SWIG_ConvertFunctionPtr(obj3, (void**)(&arg4), SWIGTYPE_p_f_p_q_const__float_p_q_const__float_p_void__float);
if (!SWIG_IsOK(res)) {
SWIG_exception_fail(SWIG_ArgError(res), "in method '" "cvCalcEMD2" "', argument " "4"" of type '" "CvDistanceFunction""'");
}
}
}
if (obj4) {
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
}
if (obj5) {
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
}
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalcEMD2" "', argument " "7"" of type '" "float *""'");
}
arg7 = reinterpret_cast< float * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7,SWIG_as_voidptrptr(&arg8), 0, 0);
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvCalcEMD2" "', argument " "8"" of type '" "void *""'");
}
}
{
try {
result = (float)cvCalcEMD2((void const *)arg1,(void const *)arg2,arg3,arg4,(void const *)arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_float(static_cast< float >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindContoursUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
CvSeq **arg3 = (CvSeq **) 0 ;
int arg4 = (int) sizeof(CvContour) ;
int arg5 = (int) 1 ;
int arg6 = (int) 2 ;
CvPoint arg7 = (CvPoint) cvPoint(0,0) ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
CvSeq *seq3 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
{
arg3 = &seq3;
}
if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:cvFindContoursUntyped",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindContoursUntyped" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (obj2) {
ecode4 = SWIG_AsVal_int(obj2, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvFindContoursUntyped" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj3) {
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindContoursUntyped" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj4) {
ecode6 = SWIG_AsVal_int(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFindContoursUntyped" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj5) {
{
arg7 = PyObject_to_CvPoint(obj5);
}
}
{
try {
result = (int)cvFindContours(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
PyObject *to_add;
/* extract the pointer we want to add to the returned tuple */
/* sequence is allocated in CvMemStorage, so python_ownership=0 */
to_add = SWIG_NewPointerObj (*arg3, SWIGTYPE_p_CvSeq, 0);
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartFindContours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
int arg3 = (int) sizeof(CvContour) ;
int arg4 = (int) 1 ;
int arg5 = (int) 2 ;
CvPoint arg6 = (CvPoint) cvPoint(0,0) ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvContourScanner result;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:cvStartFindContours",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartFindContours" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvStartFindContours" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvStartFindContours" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvStartFindContours" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
{
arg6 = PyObject_to_CvPoint(obj5);
}
}
{
try {
result = (CvContourScanner)cvStartFindContours(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CvContourScanner, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindNextContour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourScanner arg1 = (CvContourScanner) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvFindNextContour",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CvContourScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindNextContour" "', argument " "1"" of type '" "CvContourScanner""'");
}
arg1 = reinterpret_cast< CvContourScanner >(argp1);
{
try {
result = (CvSeq *)cvFindNextContour(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubstituteContour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourScanner arg1 = (CvContourScanner) 0 ;
CvSeq *arg2 = (CvSeq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *ptr2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSubstituteContour",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CvContourScanner, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSubstituteContour" "', argument " "1"" of type '" "CvContourScanner""'");
}
arg1 = reinterpret_cast< CvContourScanner >(argp1);
{
if( SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj1, &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg2 = (CvSeq *) ptr2;
}
{
try {
cvSubstituteContour(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEndFindContours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourScanner *arg1 = (CvContourScanner *) 0 ;
void *vptr1 ;
CvContourScanner buffer1 ;
PyObject * obj0 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvEndFindContours",&obj0)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p__CvContourScanner, 1)) == -1){
SWIG_fail;
}
buffer1 = (CvContourScanner) vptr1;
arg1=&buffer1;
}
{
try {
result = (CvSeq *)cvEndFindContours(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvApproxChainsUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
int arg3 = (int) 2 ;
double arg4 = (double) 0 ;
int arg5 = (int) 0 ;
int arg6 = (int) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:cvApproxChainsUntyped",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvApproxChainsUntyped" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvApproxChainsUntyped" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvApproxChainsUntyped" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvApproxChainsUntyped" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvApproxChainsUntyped" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
result = (CvSeq *)cvApproxChains(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStartReadChainPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChain *arg1 = (CvChain *) 0 ;
CvChainPtReader *arg2 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvStartReadChainPoints",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChain, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStartReadChainPoints" "', argument " "1"" of type '" "CvChain *""'");
}
arg1 = reinterpret_cast< CvChain * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStartReadChainPoints" "', argument " "2"" of type '" "CvChainPtReader *""'");
}
arg2 = reinterpret_cast< CvChainPtReader * >(argp2);
{
try {
cvStartReadChainPoints(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReadChainPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvChainPtReader *arg1 = (CvChainPtReader *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"O:cvReadChainPoint",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReadChainPoint" "', argument " "1"" of type '" "CvChainPtReader *""'");
}
arg1 = reinterpret_cast< CvChainPtReader * >(argp1);
{
try {
result = cvReadChainPoint(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcOpticalFlowLK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSize arg3 ;
CvArr *arg4 = (CvArr *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 ;
int res3 = 0 ;
bool freearg4 = false ;
bool freearg5 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCalcOpticalFlowLK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcOpticalFlowLK" "', argument " "3"" of type '" "CvSize""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowLK" "', argument " "3"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
{
try {
cvCalcOpticalFlowLK((void const *)arg1,(void const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcOpticalFlowBM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSize arg3 ;
CvSize arg4 ;
CvSize arg5 ;
int arg6 ;
CvArr *arg7 = (CvArr *) 0 ;
CvArr *arg8 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 ;
int res5 = 0 ;
int val6 ;
int ecode6 = 0 ;
bool freearg7 = false ;
bool freearg8 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:cvCalcOpticalFlowBM",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcOpticalFlowBM" "', argument " "3"" of type '" "CvSize""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowBM" "', argument " "3"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcOpticalFlowBM" "', argument " "4"" of type '" "CvSize""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowBM" "', argument " "4"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCalcOpticalFlowBM" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowBM" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcOpticalFlowBM" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
arg7 = PyObject_to_CvArr(obj6, &freearg7);
}
{
arg8 = PyObject_to_CvArr(obj7, &freearg8);
}
{
try {
cvCalcOpticalFlowBM((void const *)arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg7!=NULL && freearg7){
cvReleaseData( arg7 );
cvFree(&(arg7));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg7!=NULL && freearg7){
cvReleaseData( arg7 );
cvFree(&(arg7));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcOpticalFlowHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
CvArr *arg4 = (CvArr *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
double arg6 ;
CvTermCriteria arg7 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
bool freearg5 = false ;
double val6 ;
int ecode6 = 0 ;
void *argp7 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:cvCalcOpticalFlowHS",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCalcOpticalFlowHS" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcOpticalFlowHS" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalcOpticalFlowHS" "', argument " "7"" of type '" "CvTermCriteria""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowHS" "', argument " "7"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
{
try {
cvCalcOpticalFlowHS((void const *)arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcOpticalFlowPyrLK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvPoint2D32f *arg5 = (CvPoint2D32f *) 0 ;
CvPoint2D32f *arg6 = (CvPoint2D32f *) 0 ;
int arg7 ;
CvSize arg8 ;
int arg9 ;
char *arg10 = (char *) 0 ;
float *arg11 = (float *) 0 ;
CvTermCriteria arg12 ;
int arg13 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
int tmpCount6 ;
void *argp8 ;
int res8 = 0 ;
int val9 ;
int ecode9 = 0 ;
int tmpCountStatus10 ;
void *argp11 = 0 ;
int res11 = 0 ;
void *argp12 ;
int res12 = 0 ;
int val13 ;
int ecode13 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:cvCalcOpticalFlowPyrLK",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
int i;
int size;
/* get the size of the input array */
size = PyList_Size (obj4);
/* allocate the needed memory */
arg5 = (CvPoint2D32f *)malloc (size * sizeof (CvPoint2D32f));
/* extract all the points values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj4, i);
void * vptr;
SWIG_Python_ConvertPtr (item, &vptr,
SWIGTYPE_p_CvPoint2D32f,
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *)vptr;
arg5 [i].x = p->x;
arg5 [i].y = p->y;
}
}
{
/* as input, we only need the size of the wanted features */
/* memorize the size of the wanted features */
tmpCount6 = (int)PyInt_AsLong (obj5);
/* create the array for the C call */
arg6 = (CvPoint2D32f *) malloc(tmpCount6 * sizeof (CvPoint2D32f));
/* the size of the array for the C call */
arg7 = tmpCount6;
}
{
res8 = SWIG_ConvertPtr(obj6, &argp8, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "8"" of type '" "CvSize""'");
}
if (!argp8) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "8"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp8);
arg8 = *temp;
if (SWIG_IsNewObj(res8)) delete temp;
}
}
ecode9 = SWIG_AsVal_int(obj7, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
{
/* as input, we still need the size of the status array */
/* memorize the size of the status array */
tmpCountStatus10 = (int)PyInt_AsLong (obj8);
/* create the status array for the C call */
arg10 = (char *)malloc (tmpCountStatus10 * sizeof (char));
}
res11 = SWIG_ConvertPtr(obj9, &argp11,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res11)) {
SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "11"" of type '" "float *""'");
}
arg11 = reinterpret_cast< float * >(argp11);
{
res12 = SWIG_ConvertPtr(obj10, &argp12, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res12)) {
SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "12"" of type '" "CvTermCriteria""'");
}
if (!argp12) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "12"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp12);
arg12 = *temp;
if (SWIG_IsNewObj(res12)) delete temp;
}
}
ecode13 = SWIG_AsVal_int(obj11, &val13);
if (!SWIG_IsOK(ecode13)) {
SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "13"" of type '" "int""'");
}
arg13 = static_cast< int >(val13);
{
try {
cvCalcOpticalFlowPyrLK((void const *)arg1,(void const *)arg2,arg3,arg4,(CvPoint2D32f const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (tmpCount6);
/* extract all the points values of the result, and add it to the
final resulting list */
for (i = 0; i < tmpCount6; i++) {
PyList_SetItem (to_add, i,
SWIG_NewPointerObj (&(arg6 [i]),
SWIGTYPE_p_CvPoint2D32f, 0));
}
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (tmpCountStatus10);
/* extract all the integer values of the result, and add it to the
final resulting list */
for (i = 0; i < tmpCountStatus10; i++) {
PyList_SetItem (to_add, i, PyBool_FromLong (arg10 [i]));
}
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
{
PyObject * to_add = SWIG_NewPointerObj (arg11, SWIGTYPE_p_float, SWIG_POINTER_OWN);
resultobj = SWIG_Python_AppendOutput(resultobj, to_add);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcAffineFlowPyrLK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvPoint2D32f *arg5 = (CvPoint2D32f *) 0 ;
CvPoint2D32f *arg6 = (CvPoint2D32f *) 0 ;
float *arg7 = (float *) 0 ;
int arg8 ;
CvSize arg9 ;
int arg10 ;
char *arg11 = (char *) 0 ;
float *arg12 = (float *) 0 ;
CvTermCriteria arg13 ;
int arg14 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
int val8 ;
int ecode8 = 0 ;
void *argp9 ;
int res9 = 0 ;
int val10 ;
int ecode10 = 0 ;
int tmpCountStatus11 ;
void *argp12 = 0 ;
int res12 = 0 ;
void *argp13 ;
int res13 = 0 ;
int val14 ;
int ecode14 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
PyObject * obj13 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:cvCalcAffineFlowPyrLK",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
int i;
int size;
/* get the size of the input array */
size = PyList_Size (obj4);
/* allocate the needed memory */
arg5 = (CvPoint2D32f *)malloc (size * sizeof (CvPoint2D32f));
/* extract all the points values from the list */
for (i = 0; i < size; i++) {
PyObject *item = PyList_GetItem (obj4, i);
void * vptr;
SWIG_Python_ConvertPtr (item, &vptr,
SWIGTYPE_p_CvPoint2D32f,
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *)vptr;
arg5 [i].x = p->x;
arg5 [i].y = p->y;
}
}
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "6"" of type '" "CvPoint2D32f *""'");
}
arg6 = reinterpret_cast< CvPoint2D32f * >(argp6);
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "7"" of type '" "float *""'");
}
arg7 = reinterpret_cast< float * >(argp7);
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "9"" of type '" "CvSize""'");
}
if (!argp9) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcAffineFlowPyrLK" "', argument " "9"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp9);
arg9 = *temp;
if (SWIG_IsNewObj(res9)) delete temp;
}
}
ecode10 = SWIG_AsVal_int(obj9, &val10);
if (!SWIG_IsOK(ecode10)) {
SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "10"" of type '" "int""'");
}
arg10 = static_cast< int >(val10);
{
/* as input, we still need the size of the status array */
/* memorize the size of the status array */
tmpCountStatus11 = (int)PyInt_AsLong (obj10);
/* create the status array for the C call */
arg11 = (char *)malloc (tmpCountStatus11 * sizeof (char));
}
res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res12)) {
SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "12"" of type '" "float *""'");
}
arg12 = reinterpret_cast< float * >(argp12);
{
res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res13)) {
SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "13"" of type '" "CvTermCriteria""'");
}
if (!argp13) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcAffineFlowPyrLK" "', argument " "13"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp13);
arg13 = *temp;
if (SWIG_IsNewObj(res13)) delete temp;
}
}
ecode14 = SWIG_AsVal_int(obj13, &val14);
if (!SWIG_IsOK(ecode14)) {
SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "14"" of type '" "int""'");
}
arg14 = static_cast< int >(val14);
{
try {
cvCalcAffineFlowPyrLK((void const *)arg1,(void const *)arg2,arg3,arg4,(CvPoint2D32f const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (tmpCountStatus11);
/* extract all the integer values of the result, and add it to the
final resulting list */
for (i = 0; i < tmpCountStatus11; i++) {
PyList_SetItem (to_add, i, PyBool_FromLong (arg11 [i]));
}
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
{
PyObject * to_add = SWIG_NewPointerObj (arg12, SWIGTYPE_p_float, SWIG_POINTER_OWN);
resultobj = SWIG_Python_AppendOutput(resultobj, to_add);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEstimateRigidTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
int arg4 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvEstimateRigidTransform",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvEstimateRigidTransform" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEstimateRigidTransform" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (int)cvEstimateRigidTransform((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvUpdateMotionHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
double arg4 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvUpdateMotionHistory",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvUpdateMotionHistory" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvUpdateMotionHistory" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
{
try {
cvUpdateMotionHistory((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcMotionGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 ;
double arg5 ;
int arg6 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvCalcMotionGradient",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCalcMotionGradient" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcMotionGradient" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcMotionGradient" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvCalcMotionGradient((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcGlobalOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
double arg4 ;
double arg5 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCalcGlobalOrientation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCalcGlobalOrientation" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcGlobalOrientation" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
{
try {
result = (double)cvCalcGlobalOrientation((void const *)arg1,(void const *)arg2,(void const *)arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvAcc",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
{
try {
cvAcc((void const *)arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSquareAcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSquareAcc",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
}
{
try {
cvSquareAcc((void const *)arg1,arg2,(void const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMultiplyAcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvMultiplyAcc",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvMultiplyAcc((void const *)arg1,(void const *)arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRunningAvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
CvArr *arg4 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvRunningAvg",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRunningAvg" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvRunningAvg((void const *)arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCamShift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvRect arg2 ;
CvTermCriteria arg3 ;
CvConnectedComp *arg4 = (CvConnectedComp *) 0 ;
CvBox2D *arg5 = (CvBox2D *) NULL ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
void *argp3 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvCamShift",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCamShift" "', argument " "2"" of type '" "CvRect""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCamShift" "', argument " "2"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCamShift" "', argument " "3"" of type '" "CvTermCriteria""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCamShift" "', argument " "3"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCamShift" "', argument " "4"" of type '" "CvConnectedComp *""'");
}
arg4 = reinterpret_cast< CvConnectedComp * >(argp4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvBox2D, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCamShift" "', argument " "5"" of type '" "CvBox2D *""'");
}
arg5 = reinterpret_cast< CvBox2D * >(argp5);
}
{
try {
result = (int)cvCamShift((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMeanShift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvRect arg2 ;
CvTermCriteria arg3 ;
CvConnectedComp *arg4 = (CvConnectedComp *) 0 ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
void *argp3 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMeanShift",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMeanShift" "', argument " "2"" of type '" "CvRect""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvMeanShift" "', argument " "2"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvMeanShift" "', argument " "3"" of type '" "CvTermCriteria""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvMeanShift" "', argument " "3"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMeanShift" "', argument " "4"" of type '" "CvConnectedComp *""'");
}
arg4 = reinterpret_cast< CvConnectedComp * >(argp4);
{
try {
result = (int)cvMeanShift((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateConDensation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvConDensation *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCreateConDensation",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateConDensation" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateConDensation" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateConDensation" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (CvConDensation *)cvCreateConDensation(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConDensation, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConDensUpdateByTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvConDensUpdateByTime",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvConDensUpdateByTime" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
{
try {
cvConDensUpdateByTime(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConDensInitSampleSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvConDensation *arg1 = (CvConDensation *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvConDensInitSampleSet",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvConDensInitSampleSet" "', argument " "1"" of type '" "CvConDensation *""'");
}
arg1 = reinterpret_cast< CvConDensation * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvConDensInitSampleSet" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvConDensInitSampleSet" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
cvConDensInitSampleSet(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateKalman(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 = (int) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvKalman *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvCreateKalman",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateKalman" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateKalman" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateKalman" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = (CvKalman *)cvCreateKalman(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKalman, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvKalmanPredict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvKalmanPredict",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvKalmanPredict" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvKalmanPredict" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
}
{
try {
result = (CvMat *)cvKalmanPredict(arg1,(CvMat const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvKalmanCorrect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvKalman *arg1 = (CvKalman *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvKalmanCorrect",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvKalman, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvKalmanCorrect" "', argument " "1"" of type '" "CvKalman *""'");
}
arg1 = reinterpret_cast< CvKalman * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvKalmanCorrect" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
{
try {
result = (CvMat *)cvKalmanCorrect(arg1,(CvMat const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitSubdivDelaunay2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvRect arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvInitSubdivDelaunay2D",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitSubdivDelaunay2D" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitSubdivDelaunay2D" "', argument " "2"" of type '" "CvRect""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvInitSubdivDelaunay2D" "', argument " "2"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
try {
cvInitSubdivDelaunay2D(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSubdiv2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMemStorage *arg5 = (CvMemStorage *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvSubdiv2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvCreateSubdiv2D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateSubdiv2D" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateSubdiv2D" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateSubdiv2D" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCreateSubdiv2D" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCreateSubdiv2D" "', argument " "5"" of type '" "CvMemStorage *""'");
}
arg5 = reinterpret_cast< CvMemStorage * >(argp5);
{
try {
result = (CvSubdiv2D *)cvCreateSubdiv2D(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateSubdivDelaunay2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect arg1 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
void *argp1 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreateSubdivDelaunay2D",&obj0,&obj1)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateSubdivDelaunay2D" "', argument " "1"" of type '" "CvRect""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCreateSubdivDelaunay2D" "', argument " "1"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCreateSubdivDelaunay2D" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
{
try {
result = (CvSubdiv2D *)cvCreateSubdivDelaunay2D(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdivDelaunay2DInsert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvPoint2D32f arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2DPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSubdivDelaunay2DInsert",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSubdivDelaunay2DInsert" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
arg2 = PyObject_to_CvPoint2D32f(obj1);
}
{
try {
result = (CvSubdiv2DPoint *)cvSubdivDelaunay2DInsert(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DLocate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvPoint2D32f arg2 ;
CvSubdiv2DEdge *arg3 = (CvSubdiv2DEdge *) 0 ;
CvSubdiv2DPoint **arg4 = (CvSubdiv2DPoint **) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
CvSubdiv2DEdge tmpEdge3 ;
CvSubdiv2DPoint *tmpVertex3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2DPointLocation result;
{
arg3 = &tmpEdge3;
arg4 = &tmpVertex3;
}
if (!PyArg_ParseTuple(args,(char *)"OO:cvSubdiv2DLocate",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSubdiv2DLocate" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
arg2 = PyObject_to_CvPoint2D32f(obj1);
}
{
try {
result = (CvSubdiv2DPointLocation)cvSubdiv2DLocate(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
PyObject * to_add[2] = {
NULL, NULL
};
if(result==CV_PTLOC_INSIDE || result==CV_PTLOC_ON_EDGE){
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( tmpEdge3 );
to_add[0] = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0);
to_add[1] = Py_None;
}
if(result==CV_PTLOC_VERTEX){
to_add[0] = Py_None;
to_add[1] = SWIG_NewPointerObj( tmpVertex3, SWIGTYPE_p_CvSubdiv2DPoint, 0);
}
resultobj = SWIG_AppendResult(resultobj, to_add, 2);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcSubdivVoronoi2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCalcSubdivVoronoi2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcSubdivVoronoi2D" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
try {
cvCalcSubdivVoronoi2D(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearSubdivVoronoi2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearSubdivVoronoi2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvClearSubdivVoronoi2D" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
try {
cvClearSubdivVoronoi2D(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindNearestPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ;
CvPoint2D32f arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2DPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvFindNearestPoint2D",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindNearestPoint2D" "', argument " "1"" of type '" "CvSubdiv2D *""'");
}
arg1 = reinterpret_cast< CvSubdiv2D * >(argp1);
{
arg2 = PyObject_to_CvPoint2D32f(obj1);
}
{
try {
result = (CvSubdiv2DPoint *)cvFindNearestPoint2D(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DNextEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"O:cvSubdiv2DNextEdge",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
{
try {
result = cvSubdiv2DNextEdge(arg1);
}
catch (...)
{
SWIG_fail;
}
}
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DRotateEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
int arg2 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSubdiv2DRotateEdge",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSubdiv2DRotateEdge" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = cvSubdiv2DRotateEdge(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DSymEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
PyObject * obj0 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"O:cvSubdiv2DSymEdge",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
{
try {
result = cvSubdiv2DSymEdge(arg1);
}
catch (...)
{
SWIG_fail;
}
}
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DGetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvNextEdgeType arg2 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSubdiv2DEdge result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvSubdiv2DGetEdge",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSubdiv2DGetEdge" "', argument " "2"" of type '" "CvNextEdgeType""'");
}
arg2 = static_cast< CvNextEdgeType >(val2);
{
try {
result = cvSubdiv2DGetEdge(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
{
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result );
resultobj = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 );
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DEdgeOrg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
PyObject * obj0 = 0 ;
CvSubdiv2DPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSubdiv2DEdgeOrg",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
{
try {
result = (CvSubdiv2DPoint *)cvSubdiv2DEdgeOrg(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSubdiv2DEdgeDst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSubdiv2DEdge arg1 ;
CvSubdiv2DEdge_Wrapper *wrapper1 ;
CvQuadEdge2D *qedge1 ;
void *vptr1 ;
PyObject * obj0 = 0 ;
CvSubdiv2DPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvSubdiv2DEdgeDst",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){
wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1;
arg1 = wrapper1->ref();
}
else if( SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){
qedge1 = (CvQuadEdge2D *) vptr1;
arg1 = (CvSubdiv2DEdge)qedge1;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
return NULL;
}
}
{
try {
result = (CvSubdiv2DPoint *)cvSubdiv2DEdgeDst(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvTriangleArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f arg1 ;
CvPoint2D32f arg2 ;
CvPoint2D32f arg3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvTriangleArea",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint2D32f(obj0);
}
{
arg2 = PyObject_to_CvPoint2D32f(obj1);
}
{
arg3 = PyObject_to_CvPoint2D32f(obj2);
}
{
try {
result = (double)cvTriangleArea(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindDominantPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
int arg3 = (int) 1 ;
double arg4 = (double) 0 ;
double arg5 = (double) 0 ;
double arg6 = (double) 0 ;
double arg7 = (double) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOOO:cvFindDominantPoints",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindDominantPoints" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvFindDominantPoints" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvFindDominantPoints" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindDominantPoints" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFindDominantPoints" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvFindDominantPoints" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
{
try {
result = (CvSeq *)cvFindDominantPoints(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvBoundingRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 = (int) 0 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvRect result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvBoundingRect",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvBoundingRect" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = cvBoundingRect(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvRect(static_cast< const CvRect& >(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvContourArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvSlice arg2 = (CvSlice) cvSlice(0, 0x3fffffff) ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvContourArea",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSlice, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvContourArea" "', argument " "2"" of type '" "CvSlice""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvContourArea" "', argument " "2"" of type '" "CvSlice""'");
} else {
CvSlice * temp = reinterpret_cast< CvSlice * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
}
{
try {
result = (double)cvContourArea((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMinAreaRect2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) NULL ;
bool freearg1 = false ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvBox2D result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvMinAreaRect2",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
if (obj1) {
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMinAreaRect2" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
}
{
try {
result = cvMinAreaRect2((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvBox2D(static_cast< const CvBox2D& >(result))), SWIGTYPE_p_CvBox2D, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMinEnclosingCircle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
float *arg3 = (float *) 0 ;
bool freearg1 = false ;
CvPoint2D32f *tmp_center2 ;
float tmp_radius2 ;
PyObject * obj0 = 0 ;
int result;
{
tmp_center2 = (CvPoint2D32f *) malloc(sizeof(CvPoint2D32f));
arg2 = tmp_center2;
arg3 = &tmp_radius2;
}
if (!PyArg_ParseTuple(args,(char *)"O:cvMinEnclosingCircle",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (int)cvMinEnclosingCircle((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
PyObject * to_add[2] = {
NULL, NULL
};
to_add[0] = SWIG_NewPointerObj( tmp_center2, SWIGTYPE_p_CvPoint2D32f, 1);
to_add[1] = PyFloat_FromDouble( tmp_radius2 );
resultobj = SWIG_AppendResult(resultobj, to_add, 2);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMatchShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
double arg4 = (double) 0 ;
int res1 ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvMatchShapes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvMatchShapes" "', argument " "1"" of type '" "void const *""'");
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMatchShapes" "', argument " "2"" of type '" "void const *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMatchShapes" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMatchShapes" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
result = (double)cvMatchShapes((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateContourTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
double arg3 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvContourTree *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCreateContourTree",&obj0,&obj1,&obj2)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCreateContourTree" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateContourTree" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
try {
result = (CvContourTree *)cvCreateContourTree((CvSeq const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvContourTree, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvContourFromContourTreeUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvMemStorage *arg2 = (CvMemStorage *) 0 ;
CvTermCriteria arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvContourFromContourTreeUntyped",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvContourFromContourTreeUntyped" "', argument " "1"" of type '" "CvContourTree const *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvContourFromContourTreeUntyped" "', argument " "2"" of type '" "CvMemStorage *""'");
}
arg2 = reinterpret_cast< CvMemStorage * >(argp2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvContourFromContourTreeUntyped" "', argument " "3"" of type '" "CvTermCriteria""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvContourFromContourTreeUntyped" "', argument " "3"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
{
try {
result = (CvSeq *)cvContourFromContourTree((CvContourTree const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMatchContourTrees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvContourTree *arg1 = (CvContourTree *) 0 ;
CvContourTree *arg2 = (CvContourTree *) 0 ;
int arg3 ;
double arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvMatchContourTrees",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvMatchContourTrees" "', argument " "1"" of type '" "CvContourTree const *""'");
}
arg1 = reinterpret_cast< CvContourTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvContourTree, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMatchContourTrees" "', argument " "2"" of type '" "CvContourTree const *""'");
}
arg2 = reinterpret_cast< CvContourTree * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvMatchContourTrees" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvMatchContourTrees" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
{
try {
result = (double)cvMatchContourTrees((CvContourTree const *)arg1,(CvContourTree const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcPGH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
CvHistogram *arg2 = (CvHistogram *) 0 ;
void *ptr1 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCalcPGH",&obj0,&obj1)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcPGH" "', argument " "2"" of type '" "CvHistogram *""'");
}
arg2 = reinterpret_cast< CvHistogram * >(argp2);
{
try {
cvCalcPGH((CvSeq const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCheckContourConvexity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:cvCheckContourConvexity",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = (int)cvCheckContourConvexity((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvexityDefectsUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMemStorage *arg3 = (CvMemStorage *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvConvexityDefectsUntyped",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvConvexityDefectsUntyped" "', argument " "3"" of type '" "CvMemStorage *""'");
}
arg3 = reinterpret_cast< CvMemStorage * >(argp3);
}
{
try {
result = (CvSeq *)cvConvexityDefects((void const *)arg1,(void const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFitEllipse2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
bool freearg1 = false ;
PyObject * obj0 = 0 ;
CvBox2D result;
if (!PyArg_ParseTuple(args,(char *)"O:cvFitEllipse2",&obj0)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
try {
result = cvFitEllipse2((void const *)arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvBox2D(static_cast< const CvBox2D& >(result))), SWIGTYPE_p_CvBox2D, SWIG_POINTER_OWN | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMaxRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvRect *arg1 = (CvRect *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvRect result;
if (!PyArg_ParseTuple(args,(char *)"OO:cvMaxRect",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvMaxRect" "', argument " "1"" of type '" "CvRect const *""'");
}
arg1 = reinterpret_cast< CvRect * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvMaxRect" "', argument " "2"" of type '" "CvRect const *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
{
try {
result = cvMaxRect((CvRect const *)arg1,(CvRect const *)arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvRect(static_cast< const CvRect& >(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvBoxPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBox2D arg1 ;
CvPoint2D32f *arg2 ;
void *argp1 ;
int res1 = 0 ;
CvPoint2D32f tmp_pts2[4] ;
PyObject * obj0 = 0 ;
{
arg2 = tmp_pts2;
}
if (!PyArg_ParseTuple(args,(char *)"O:cvBoxPoints",&obj0)) SWIG_fail;
{
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CvBox2D, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvBoxPoints" "', argument " "1"" of type '" "CvBox2D""'");
}
if (!argp1) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvBoxPoints" "', argument " "1"" of type '" "CvBox2D""'");
} else {
CvBox2D * temp = reinterpret_cast< CvBox2D * >(argp1);
arg1 = *temp;
if (SWIG_IsNewObj(res1)) delete temp;
}
}
{
try {
cvBoxPoints(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
PyObject * to_add = PyList_New(4);
int i;
for(i=0; i<4; i++){
CvPoint2D32f * p = new CvPoint2D32f;
*p = tmp_pts2[i];
PyList_SetItem(to_add, i, SWIG_NewPointerObj( p, SWIGTYPE_p_CvPoint2D32f, 1 ) );
}
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPointSeqFromMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
CvArr *arg2 = (CvArr *) 0 ;
CvContour *arg3 = (CvContour *) 0 ;
CvSeqBlock *arg4 = (CvSeqBlock *) 0 ;
int val1 ;
int ecode1 = 0 ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvPointSeqFromMat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPointSeqFromMat" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvContour, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvPointSeqFromMat" "', argument " "3"" of type '" "CvContour *""'");
}
arg3 = reinterpret_cast< CvContour * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvSeqBlock, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvPointSeqFromMat" "', argument " "4"" of type '" "CvSeqBlock *""'");
}
arg4 = reinterpret_cast< CvSeqBlock * >(argp4);
{
try {
result = (CvSeq *)cvPointSeqFromMat(arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPointPolygonTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint2D32f arg2 ;
int arg3 ;
bool freearg1 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvPointPolygonTest",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint2D32f(obj1);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPointPolygonTest" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvPointPolygonTest((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int arg3 ;
float **arg4 = (float **) NULL ;
int arg5 = (int) 1 ;
int val3 ;
int ecode3 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvHistogram *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvCreateHist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
int i;
/* get the size of the dimention array */
arg1 = PyList_Size (obj0);
/* allocate the needed memory */
arg2 = (int *)malloc (arg1 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg1; i++) {
PyObject *item = PyList_GetItem (obj0, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
ecode3 = SWIG_AsVal_int(obj1, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateHist" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj2) {
{
int i1;
int i2;
int size1;
int size2 = 0;
/* get the number of lines of the matrix */
size1 = PyList_Size (obj2);
/* allocate the correct number of lines for the destination matrix */
arg4 = (float **)malloc (size1 * sizeof (float *));
for (i1 = 0; i1 < size1; i1++) {
/* extract all the lines of the matrix */
PyObject *list = PyList_GetItem (obj2, i1);
if (size2 == 0) {
/* size 2 wasn't computed before */
size2 = PyList_Size (list);
} else if (size2 != PyList_Size (list)) {
/* the current line as a different size than the previous one */
/* so, generate an exception */
SWIG_exception (SWIG_ValueError, "Lines must be the same size");
}
/* allocate the correct number of rows for the current line */
arg4 [i1] = (float *)malloc (size2 * sizeof (float));
/* extract all the float values of this row */
for (i2 = 0; i2 < size2; i2++) {
PyObject *item = PyList_GetItem (list, i2);
arg4 [i1][i2] = (float)PyFloat_AsDouble (item);
}
}
}
}
if (obj3) {
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCreateHist" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
result = (CvHistogram *)cvCreateHist(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHistogram, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetHistBinRanges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
float **arg2 = (float **) 0 ;
int arg3 = (int) 1 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvSetHistBinRanges",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSetHistBinRanges" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
int i1;
int i2;
int size1;
int size2 = 0;
/* get the number of lines of the matrix */
size1 = PyList_Size (obj1);
/* allocate the correct number of lines for the destination matrix */
arg2 = (float **)malloc (size1 * sizeof (float *));
for (i1 = 0; i1 < size1; i1++) {
/* extract all the lines of the matrix */
PyObject *list = PyList_GetItem (obj1, i1);
if (size2 == 0) {
/* size 2 wasn't computed before */
size2 = PyList_Size (list);
} else if (size2 != PyList_Size (list)) {
/* the current line as a different size than the previous one */
/* so, generate an exception */
SWIG_exception (SWIG_ValueError, "Lines must be the same size");
}
/* allocate the correct number of rows for the current line */
arg2 [i1] = (float *)malloc (size2 * sizeof (float));
/* extract all the float values of this row */
for (i2 = 0; i2 < size2; i2++) {
PyObject *item = PyList_GetItem (list, i2);
arg2 [i1][i2] = (float)PyFloat_AsDouble (item);
}
}
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetHistBinRanges" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvSetHistBinRanges(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvMakeHistHeaderForArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
CvHistogram *arg3 = (CvHistogram *) 0 ;
float *arg4 = (float *) 0 ;
float **arg5 = (float **) NULL ;
int arg6 = (int) 1 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvHistogram *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvMakeHistHeaderForArray",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
int i;
/* get the size of the dimention array */
arg1 = PyList_Size (obj0);
/* allocate the needed memory */
arg2 = (int *)malloc (arg1 * sizeof (int));
/* extract all the integer values from the list */
for (i = 0; i < arg1; i++) {
PyObject *item = PyList_GetItem (obj0, i);
arg2 [i] = (int)PyInt_AsLong (item);
}
}
res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvMakeHistHeaderForArray" "', argument " "3"" of type '" "CvHistogram *""'");
}
arg3 = reinterpret_cast< CvHistogram * >(argp3);
res4 = SWIG_ConvertPtr(obj2, &argp4,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMakeHistHeaderForArray" "', argument " "4"" of type '" "float *""'");
}
arg4 = reinterpret_cast< float * >(argp4);
if (obj3) {
{
int i1;
int i2;
int size1;
int size2 = 0;
/* get the number of lines of the matrix */
size1 = PyList_Size (obj3);
/* allocate the correct number of lines for the destination matrix */
arg5 = (float **)malloc (size1 * sizeof (float *));
for (i1 = 0; i1 < size1; i1++) {
/* extract all the lines of the matrix */
PyObject *list = PyList_GetItem (obj3, i1);
if (size2 == 0) {
/* size 2 wasn't computed before */
size2 = PyList_Size (list);
} else if (size2 != PyList_Size (list)) {
/* the current line as a different size than the previous one */
/* so, generate an exception */
SWIG_exception (SWIG_ValueError, "Lines must be the same size");
}
/* allocate the correct number of rows for the current line */
arg5 [i1] = (float *)malloc (size2 * sizeof (float));
/* extract all the float values of this row */
for (i2 = 0; i2 < size2; i2++) {
PyObject *item = PyList_GetItem (list, i2);
arg5 [i1][i2] = (float)PyFloat_AsDouble (item);
}
}
}
}
if (obj4) {
ecode6 = SWIG_AsVal_int(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvMakeHistHeaderForArray" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
result = (CvHistogram *)cvMakeHistHeaderForArray(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHistogram, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvClearHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvClearHist",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvClearHist" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
try {
cvClearHist(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGetMinMaxHistValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
float *arg2 = (float *) 0 ;
float *arg3 = (float *) 0 ;
int *arg4 = (int *) NULL ;
int *arg5 = (int *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
float temp2 ;
int res2 = SWIG_TMPOBJ ;
float temp3 ;
int res3 = SWIG_TMPOBJ ;
int temp4 ;
int res4 = SWIG_TMPOBJ ;
int temp5 ;
int res5 = SWIG_TMPOBJ ;
PyObject * obj0 = 0 ;
arg2 = &temp2;
arg3 = &temp3;
arg4 = &temp4;
arg5 = &temp5;
if (!PyArg_ParseTuple(args,(char *)"O:cvGetMinMaxHistValue",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvGetMinMaxHistValue" "', argument " "1"" of type '" "CvHistogram const *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
try {
cvGetMinMaxHistValue((CvHistogram const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
if (SWIG_IsTmpObj(res2)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)));
} else {
int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags));
}
if (SWIG_IsTmpObj(res3)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)));
} else {
int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags));
}
if (SWIG_IsTmpObj(res4)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
} else {
int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
}
if (SWIG_IsTmpObj(res5)) {
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
} else {
int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvNormalizeHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvNormalizeHist",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvNormalizeHist" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvNormalizeHist" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
cvNormalizeHist(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvThreshHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvThreshHist",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvThreshHist" "', argument " "1"" of type '" "CvHistogram *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvThreshHist" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
cvThreshHist(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCompareHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
CvHistogram *arg2 = (CvHistogram *) 0 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCompareHist",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCompareHist" "', argument " "1"" of type '" "CvHistogram const *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCompareHist" "', argument " "2"" of type '" "CvHistogram const *""'");
}
arg2 = reinterpret_cast< CvHistogram * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCompareHist" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
result = (double)cvCompareHist((CvHistogram const *)arg1,(CvHistogram const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCopyHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
CvHistogram **arg2 = (CvHistogram **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
CvHistogram *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCopyHist",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCopyHist" "', argument " "1"" of type '" "CvHistogram const *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvHistogram, 1)) == -1){
SWIG_fail;
}
buffer2 = (CvHistogram *) vptr2;
arg2=&buffer2;
}
{
try {
cvCopyHist((CvHistogram const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcBayesianProb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram **arg1 = (CvHistogram **) 0 ;
int arg2 ;
CvHistogram **arg3 = (CvHistogram **) 0 ;
void *vptr1 ;
CvHistogram *buffer1 ;
int val2 ;
int ecode2 = 0 ;
void *vptr3 ;
CvHistogram *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCalcBayesianProb",&obj0,&obj1,&obj2)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p_CvHistogram, 1)) == -1){
SWIG_fail;
}
buffer1 = (CvHistogram *) vptr1;
arg1=&buffer1;
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCalcBayesianProb" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvHistogram, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvHistogram *) vptr3;
arg3=&buffer3;
}
{
try {
cvCalcBayesianProb(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcArrHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr **arg1 = (CvArr **) 0 ;
CvHistogram *arg2 = (CvHistogram *) 0 ;
int arg3 = (int) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
CvArr *one_image1 = NULL ;
bool free_one_arg1 = false ;
CvArr **many_images1 = NULL ;
bool *free_many_args1 = NULL ;
int nimages1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvCalcArrHist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
/* first, check if this is a tuple */
if PyTuple_Check (obj0) {
/* This is a tuple, so we need to test each element and pass
them to the called function */
int i;
/* get the size of the tuple */
nimages1 = PyTuple_Size (obj0);
/* allocate the necessary place */
many_images1 = (CvArr **)malloc (nimages1 * sizeof (CvArr *));
free_many_args1 = (bool *)malloc(nimages1 * sizeof(bool));
for (i = 0; i < nimages1; i++) {
/* convert the current tuple element to a CvArr *, and
store to many_images1 [i] */
many_images1[i] = PyObject_to_CvArr (PyTuple_GetItem (obj0, i),
free_many_args1+i);
/* check that the current item is a correct type */
if(!many_images1[i]) {
/* incorrect ! */
SWIG_fail;
}
}
/* what to give to the called function */
arg1 = many_images1;
} else if((one_image1 = PyObject_to_CvArr( obj0, &free_one_arg1 ))){
/* this is just one CvArr *, so one_image1 will receive it */
arg1 = &one_image1;
} else {
/* not a CvArr *, not a tuple, this is wrong */
SWIG_fail;
}
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcArrHist" "', argument " "2"" of type '" "CvHistogram *""'");
}
arg2 = reinterpret_cast< CvHistogram * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCalcArrHist" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvCalcArrHist(arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcImageHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
IplImage **arg1 = (IplImage **) 0 ;
CvHistogram *arg2 = (CvHistogram *) 0 ;
int arg3 = (int) 0 ;
CvArr *arg4 = (CvArr *) NULL ;
void *vptr1 ;
IplImage *buffer1 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OO:cvCalcImageHist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
if ((SWIG_ConvertPtr(obj0, &vptr1, SWIGTYPE_p__IplImage, 1)) == -1){
SWIG_fail;
}
buffer1 = (IplImage *) vptr1;
arg1=&buffer1;
}
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcImageHist" "', argument " "2"" of type '" "CvHistogram *""'");
}
arg2 = reinterpret_cast< CvHistogram * >(argp2);
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCalcImageHist" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
}
{
try {
cvCalcHist(arg1,arg2,arg3,(void const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcArrBackProject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr **arg1 = (CvArr **) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvHistogram *arg3 = (CvHistogram *) 0 ;
CvArr *one_image1 = NULL ;
bool free_one_arg1 = false ;
CvArr **many_images1 = NULL ;
bool *free_many_args1 = NULL ;
int nimages1 = 0 ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvCalcArrBackProject",&obj0,&obj1,&obj2)) SWIG_fail;
{
/* first, check if this is a tuple */
if PyTuple_Check (obj0) {
/* This is a tuple, so we need to test each element and pass
them to the called function */
int i;
/* get the size of the tuple */
nimages1 = PyTuple_Size (obj0);
/* allocate the necessary place */
many_images1 = (CvArr **)malloc (nimages1 * sizeof (CvArr *));
free_many_args1 = (bool *)malloc(nimages1 * sizeof(bool));
for (i = 0; i < nimages1; i++) {
/* convert the current tuple element to a CvArr *, and
store to many_images1 [i] */
many_images1[i] = PyObject_to_CvArr (PyTuple_GetItem (obj0, i),
free_many_args1+i);
/* check that the current item is a correct type */
if(!many_images1[i]) {
/* incorrect ! */
SWIG_fail;
}
}
/* what to give to the called function */
arg1 = many_images1;
} else if((one_image1 = PyObject_to_CvArr( obj0, &free_one_arg1 ))){
/* this is just one CvArr *, so one_image1 will receive it */
arg1 = &one_image1;
} else {
/* not a CvArr *, not a tuple, this is wrong */
SWIG_fail;
}
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcArrBackProject" "', argument " "3"" of type '" "CvHistogram const *""'");
}
arg3 = reinterpret_cast< CvHistogram * >(argp3);
{
try {
cvCalcArrBackProject(arg1,arg2,(CvHistogram const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcArrBackProjectPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr **arg1 = (CvArr **) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSize arg3 ;
CvHistogram *arg4 = (CvHistogram *) 0 ;
int arg5 ;
double arg6 ;
CvArr *one_image1 = NULL ;
bool free_one_arg1 = false ;
CvArr **many_images1 = NULL ;
bool *free_many_args1 = NULL ;
int nimages1 = 0 ;
bool freearg2 = false ;
void *argp3 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvCalcArrBackProjectPatch",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
/* first, check if this is a tuple */
if PyTuple_Check (obj0) {
/* This is a tuple, so we need to test each element and pass
them to the called function */
int i;
/* get the size of the tuple */
nimages1 = PyTuple_Size (obj0);
/* allocate the necessary place */
many_images1 = (CvArr **)malloc (nimages1 * sizeof (CvArr *));
free_many_args1 = (bool *)malloc(nimages1 * sizeof(bool));
for (i = 0; i < nimages1; i++) {
/* convert the current tuple element to a CvArr *, and
store to many_images1 [i] */
many_images1[i] = PyObject_to_CvArr (PyTuple_GetItem (obj0, i),
free_many_args1+i);
/* check that the current item is a correct type */
if(!many_images1[i]) {
/* incorrect ! */
SWIG_fail;
}
}
/* what to give to the called function */
arg1 = many_images1;
} else if((one_image1 = PyObject_to_CvArr( obj0, &free_one_arg1 ))){
/* this is just one CvArr *, so one_image1 will receive it */
arg1 = &one_image1;
} else {
/* not a CvArr *, not a tuple, this is wrong */
SWIG_fail;
}
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcArrBackProjectPatch" "', argument " "3"" of type '" "CvSize""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcArrBackProjectPatch" "', argument " "3"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcArrBackProjectPatch" "', argument " "4"" of type '" "CvHistogram *""'");
}
arg4 = reinterpret_cast< CvHistogram * >(argp4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcArrBackProjectPatch" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcArrBackProjectPatch" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
{
try {
cvCalcArrBackProjectPatch(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(free_one_arg1){
cvFree(&(one_image1));
}
else if(free_many_args1){
int i;
for (i=0; i<nimages1; i++){
if(free_many_args1[i]){
cvReleaseData(many_images1[i]);
cvFree(many_images1+i);
}
}
free(many_images1);
free(free_many_args1);
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcProbDensity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHistogram *arg1 = (CvHistogram *) 0 ;
CvHistogram *arg2 = (CvHistogram *) 0 ;
CvHistogram *arg3 = (CvHistogram *) 0 ;
double arg4 = (double) 255 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
double val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvCalcProbDensity",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcProbDensity" "', argument " "1"" of type '" "CvHistogram const *""'");
}
arg1 = reinterpret_cast< CvHistogram * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcProbDensity" "', argument " "2"" of type '" "CvHistogram const *""'");
}
arg2 = reinterpret_cast< CvHistogram * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvHistogram, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcProbDensity" "', argument " "3"" of type '" "CvHistogram *""'");
}
arg3 = reinterpret_cast< CvHistogram * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCalcProbDensity" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
{
try {
cvCalcProbDensity((CvHistogram const *)arg1,(CvHistogram const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvEqualizeHist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvEqualizeHist",&obj0,&obj1)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
try {
cvEqualizeHist((void const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcImageHomography(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
float *arg1 = (float *) 0 ;
CvPoint3D32f *arg2 = (CvPoint3D32f *) 0 ;
float *arg3 = (float *) 0 ;
float *arg4 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCalcImageHomography",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcImageHomography" "', argument " "1"" of type '" "float *""'");
}
arg1 = reinterpret_cast< float * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcImageHomography" "', argument " "2"" of type '" "CvPoint3D32f *""'");
}
arg2 = reinterpret_cast< CvPoint3D32f * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcImageHomography" "', argument " "3"" of type '" "float *""'");
}
arg3 = reinterpret_cast< float * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcImageHomography" "', argument " "4"" of type '" "float *""'");
}
arg4 = reinterpret_cast< float * >(argp4);
{
try {
cvCalcImageHomography(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDistTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 2 ;
int arg4 = (int) 3 ;
float *arg5 = (float *) NULL ;
CvArr *arg6 = (CvArr *) NULL ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
bool freearg6 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:cvDistTransform",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvDistTransform" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvDistTransform" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvDistTransform" "', argument " "5"" of type '" "float const *""'");
}
arg5 = reinterpret_cast< float * >(argp5);
}
if (obj5) {
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
}
{
try {
cvDistTransform((void const *)arg1,arg2,arg3,arg4,(float const *)arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
double arg4 ;
int arg5 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvThreshold",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvThreshold" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvThreshold" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvThreshold" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
result = (double)cvThreshold((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvAdaptiveThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
int arg4 = (int) 0 ;
int arg5 = (int) 0 ;
int arg6 = (int) 3 ;
double arg7 = (double) 5 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOO:cvAdaptiveThreshold",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvAdaptiveThreshold" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvAdaptiveThreshold" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvAdaptiveThreshold" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvAdaptiveThreshold" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvAdaptiveThreshold" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
{
try {
cvAdaptiveThreshold((void const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFloodFill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint arg2 ;
CvScalar arg3 ;
CvScalar arg4 = (CvScalar) cvScalarAll(0) ;
CvScalar arg5 = (CvScalar) cvScalarAll(0) ;
CvConnectedComp *arg6 = (CvConnectedComp *) NULL ;
int arg7 = (int) 4 ;
CvArr *arg8 = (CvArr *) NULL ;
bool freearg1 = false ;
void *argp6 = 0 ;
int res6 = 0 ;
int val7 ;
int ecode7 = 0 ;
bool freearg8 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOOO:cvFloodFill",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvPoint(obj1);
}
{
arg3 = PyObject_to_CvScalar( obj2 );
}
if (obj3) {
{
arg4 = PyObject_to_CvScalar( obj3 );
}
}
if (obj4) {
{
arg5 = PyObject_to_CvScalar( obj4 );
}
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFloodFill" "', argument " "6"" of type '" "CvConnectedComp *""'");
}
arg6 = reinterpret_cast< CvConnectedComp * >(argp6);
}
if (obj6) {
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvFloodFill" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
}
if (obj7) {
{
arg8 = PyObject_to_CvArr(obj7, &freearg8);
}
}
{
try {
cvFloodFill(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCanny(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
double arg3 ;
double arg4 ;
int arg5 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|O:cvCanny",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCanny" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCanny" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCanny" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
cvCanny((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPreCornerDetect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvPreCornerDetect",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPreCornerDetect" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
cvPreCornerDetect((void const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCornerEigenValsAndVecs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
int arg4 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvCornerEigenValsAndVecs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCornerEigenValsAndVecs" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCornerEigenValsAndVecs" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvCornerEigenValsAndVecs((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCornerMinEigenVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
int arg4 = (int) 3 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|O:cvCornerMinEigenVal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCornerMinEigenVal" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCornerMinEigenVal" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
try {
cvCornerMinEigenVal((void const *)arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCornerHarris(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
int arg3 ;
int arg4 = (int) 3 ;
double arg5 = (double) 0.04 ;
bool freearg1 = false ;
bool freearg2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvCornerHarris",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCornerHarris" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCornerHarris" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCornerHarris" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
{
try {
cvCornerHarris((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindCornerSubPix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
int arg3 ;
CvSize arg4 ;
CvSize arg5 ;
CvTermCriteria arg6 ;
bool freearg1 = false ;
int cornersCount2 ;
CvPoint2D32f *corners2 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvFindCornerSubPix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
int i;
if(!PyList_Check(obj1)){
PyErr_SetString(PyExc_TypeError, "Expected a list");
return NULL;
}
/* get the size of the input array */
cornersCount2 = PyList_Size (obj1);
arg3 = cornersCount2;
/* allocate the needed memory */
corners2 = (CvPoint2D32f *)malloc (arg3 * sizeof (CvPoint2D32f));
arg2 = corners2;
/* the size of the array for the C call */
/* extract all the points values from the list */
for (i = 0; i < arg3; i++) {
PyObject *item = PyList_GetItem (obj1, i);
void *vptr;
SWIG_Python_ConvertPtr (item, &vptr,
SWIGTYPE_p_CvPoint2D32f,
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *) vptr;;
arg2 [i].x = p->x;
arg2 [i].y = p->y;
}
}
{
res4 = SWIG_ConvertPtr(obj2, &argp4, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindCornerSubPix" "', argument " "4"" of type '" "CvSize""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "4"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
res5 = SWIG_ConvertPtr(obj3, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvFindCornerSubPix" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
res6 = SWIG_ConvertPtr(obj4, &argp6, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFindCornerSubPix" "', argument " "6"" of type '" "CvTermCriteria""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "6"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
cvFindCornerSubPix((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (cornersCount2);
/* extract all the corner values of the result, and add it to the
final resulting list */
for (i = 0; i < cornersCount2; i++) {
PyList_SetItem (to_add, i,
SWIG_NewPointerObj (&(corners2 [i]),
SWIGTYPE_p_CvPoint2D32f, 0));
}
resultobj = SWIG_AppendResult( resultobj, &to_add, 1);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvGoodFeaturesToTrack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvPoint2D32f *arg4 = (CvPoint2D32f *) 0 ;
int *arg5 = (int *) 0 ;
double arg6 ;
double arg7 ;
CvArr *arg8 = (CvArr *) NULL ;
int arg9 = (int) 3 ;
int arg10 = (int) 0 ;
double arg11 = (double) 0.04 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
int tmpCount4 ;
double val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
bool freearg8 = false ;
int val9 ;
int ecode9 = 0 ;
int val10 ;
int ecode10 = 0 ;
double val11 ;
int ecode11 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OOOO:cvGoodFeaturesToTrack",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
/* as input, we still need the size of the corners array */
/* memorize the size of the status corners */
tmpCount4 = (int)PyInt_AsLong (obj3);
/* create the corners array for the C call */
arg4 = (CvPoint2D32f *)malloc (tmpCount4 * sizeof (CvPoint2D32f));
/* the size of the array for the C call */
arg5 = &tmpCount4;
}
ecode6 = SWIG_AsVal_double(obj4, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvGoodFeaturesToTrack" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
ecode7 = SWIG_AsVal_double(obj5, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvGoodFeaturesToTrack" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
if (obj6) {
{
arg8 = PyObject_to_CvArr(obj6, &freearg8);
}
}
if (obj7) {
ecode9 = SWIG_AsVal_int(obj7, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvGoodFeaturesToTrack" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
}
if (obj8) {
ecode10 = SWIG_AsVal_int(obj8, &val10);
if (!SWIG_IsOK(ecode10)) {
SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "cvGoodFeaturesToTrack" "', argument " "10"" of type '" "int""'");
}
arg10 = static_cast< int >(val10);
}
if (obj9) {
ecode11 = SWIG_AsVal_double(obj9, &val11);
if (!SWIG_IsOK(ecode11)) {
SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "cvGoodFeaturesToTrack" "', argument " "11"" of type '" "double""'");
}
arg11 = static_cast< double >(val11);
}
{
try {
cvGoodFeaturesToTrack((void const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(void const *)arg8,arg9,arg10,arg11);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (tmpCount4);
/* extract all the integer values of the result, and add it to the
final resulting list */
for (i = 0; i < tmpCount4; i++) {
PyList_SetItem (to_add, i,
SWIG_NewPointerObj (&(arg4 [i]),
SWIGTYPE_p_CvPoint2D32f, 0));
}
resultobj = SWIG_AppendResult(resultobj, &to_add, 1);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg8!=NULL && freearg8){
cvReleaseData( arg8 );
cvFree(&(arg8));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHoughLinesUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
double arg4 ;
double arg5 ;
int arg6 ;
double arg7 = (double) 0 ;
double arg8 = (double) 0 ;
bool freearg1 = false ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
double val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OO:cvHoughLinesUntyped",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHoughLinesUntyped" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvHoughLinesUntyped" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHoughLinesUntyped" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHoughLinesUntyped" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvHoughLinesUntyped" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvHoughLinesUntyped" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
if (obj7) {
ecode8 = SWIG_AsVal_double(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvHoughLinesUntyped" "', argument " "8"" of type '" "double""'");
}
arg8 = static_cast< double >(val8);
}
{
try {
result = (CvSeq *)cvHoughLines2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvHoughCirclesUntyped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
void *arg2 = (void *) 0 ;
int arg3 ;
double arg4 ;
double arg5 ;
double arg6 = (double) 100 ;
double arg7 = (double) 100 ;
int arg8 = (int) 0 ;
int arg9 = (int) 0 ;
bool freearg1 = false ;
int res2 ;
int val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
double val7 ;
int ecode7 = 0 ;
int val8 ;
int ecode8 = 0 ;
int val9 ;
int ecode9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
CvSeq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|OOOO:cvHoughCirclesUntyped",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHoughCirclesUntyped" "', argument " "2"" of type '" "void *""'");
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvHoughCirclesUntyped" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHoughCirclesUntyped" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHoughCirclesUntyped" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
if (obj5) {
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvHoughCirclesUntyped" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
}
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvHoughCirclesUntyped" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
if (obj7) {
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvHoughCirclesUntyped" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
}
if (obj8) {
ecode9 = SWIG_AsVal_int(obj8, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvHoughCirclesUntyped" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
}
{
try {
result = (CvSeq *)cvHoughCircles(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFitLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
int arg2 ;
double arg3 ;
double arg4 ;
double arg5 ;
float *arg6 = (float *) 0 ;
bool freearg1 = false ;
int val2 ;
int ecode2 = 0 ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvFitLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvFitLine" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvFitLine" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvFitLine" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFitLine" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFitLine" "', argument " "6"" of type '" "float *""'");
}
arg6 = reinterpret_cast< float * >(argp6);
{
try {
cvFitLine((void const *)arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreateFeatureTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvFeatureTree *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvCreateFeatureTree",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateFeatureTree" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
result = (CvFeatureTree *)cvCreateFeatureTree(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFeatureTree, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseFeatureTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFeatureTree *arg1 = (CvFeatureTree *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseFeatureTree",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFeatureTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReleaseFeatureTree" "', argument " "1"" of type '" "CvFeatureTree *""'");
}
arg1 = reinterpret_cast< CvFeatureTree * >(argp1);
{
try {
cvReleaseFeatureTree(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFeatureTree *arg1 = (CvFeatureTree *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
int arg5 = (int) 2 ;
int arg6 = (int) 20 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvFindFeatures",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFeatureTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindFeatures" "', argument " "1"" of type '" "CvFeatureTree *""'");
}
arg1 = reinterpret_cast< CvFeatureTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindFeatures" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindFeatures" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindFeatures" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
if (obj4) {
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindFeatures" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFindFeatures" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvFindFeatures(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindFeaturesBoxed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvFeatureTree *arg1 = (CvFeatureTree *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvFindFeaturesBoxed",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvFeatureTree, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindFeaturesBoxed" "', argument " "1"" of type '" "CvFeatureTree *""'");
}
arg1 = reinterpret_cast< CvFeatureTree * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindFeaturesBoxed" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindFeaturesBoxed" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindFeaturesBoxed" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
result = (int)cvFindFeaturesBoxed(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_pt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFPoint_pt_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_pt_set" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSURFPoint_pt_set" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
if (arg1) (arg1)->pt = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_pt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFPoint_pt_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_pt_get" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
result = (CvPoint2D32f *)& ((arg1)->pt);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_laplacian_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFPoint_laplacian_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_laplacian_set" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_laplacian_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->laplacian = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_laplacian_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFPoint_laplacian_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_laplacian_get" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
result = (int) ((arg1)->laplacian);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFPoint_size_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_size_set" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_size_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->size = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFPoint_size_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_size_get" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
result = (int) ((arg1)->size);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFPoint_dir_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_dir_set" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_dir_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->dir = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFPoint_dir_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_dir_get" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
result = (float) ((arg1)->dir);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_hessian_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFPoint_hessian_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_hessian_set" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_hessian_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->hessian = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFPoint_hessian_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFPoint_hessian_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_hessian_get" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
result = (float) ((arg1)->hessian);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSURFPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSURFPoint")) SWIG_fail;
{
try {
result = (CvSURFPoint *)new CvSURFPoint();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSURFPoint, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSURFPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFPoint *arg1 = (CvSURFPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSURFPoint",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFPoint, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSURFPoint" "', argument " "1"" of type '" "CvSURFPoint *""'");
}
arg1 = reinterpret_cast< CvSURFPoint * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSURFPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSURFPoint, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvSURFPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint2D32f arg1 ;
int arg2 ;
int arg3 ;
float arg4 = (float) 0 ;
float arg5 = (float) 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
float val4 ;
int ecode4 = 0 ;
float val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvSURFPoint result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OO:cvSURFPoint",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
{
arg1 = PyObject_to_CvPoint2D32f(obj0);
}
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSURFPoint" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSURFPoint" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
if (obj3) {
ecode4 = SWIG_AsVal_float(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSURFPoint" "', argument " "4"" of type '" "float""'");
}
arg4 = static_cast< float >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_float(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSURFPoint" "', argument " "5"" of type '" "float""'");
}
arg5 = static_cast< float >(val5);
}
{
try {
result = cvSURFPoint(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSURFPoint(static_cast< const CvSURFPoint& >(result))), SWIGTYPE_p_CvSURFPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_extended_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFParams_extended_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_extended_set" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_extended_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->extended = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_extended_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFParams_extended_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_extended_get" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
result = (int) ((arg1)->extended);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_hessianThreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFParams_hessianThreshold_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_hessianThreshold_set" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_hessianThreshold_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->hessianThreshold = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_hessianThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFParams_hessianThreshold_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_hessianThreshold_get" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
result = (double) ((arg1)->hessianThreshold);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_nOctaves_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFParams_nOctaves_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaves_set" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_nOctaves_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nOctaves = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_nOctaves_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFParams_nOctaves_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaves_get" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
result = (int) ((arg1)->nOctaves);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_nOctaveLayers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSURFParams_nOctaveLayers_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaveLayers_set" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_nOctaveLayers_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->nOctaveLayers = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSURFParams_nOctaveLayers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSURFParams_nOctaveLayers_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaveLayers_get" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
result = (int) ((arg1)->nOctaveLayers);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSURFParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSURFParams")) SWIG_fail;
{
try {
result = (CvSURFParams *)new CvSURFParams();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSURFParams, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSURFParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSURFParams *arg1 = (CvSURFParams *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSURFParams",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSURFParams, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSURFParams" "', argument " "1"" of type '" "CvSURFParams *""'");
}
arg1 = reinterpret_cast< CvSURFParams * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSURFParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSURFParams, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvSURFParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
int arg2 = (int) 0 ;
double val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSURFParams result;
if (!PyArg_ParseTuple(args,(char *)"O|O:cvSURFParams",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSURFParams" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSURFParams" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = cvSURFParams(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSURFParams(static_cast< const CvSURFParams& >(result))), SWIGTYPE_p_CvSURFParams, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvExtractSURF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvSeq **arg3 = (CvSeq **) 0 ;
CvSeq **arg4 = (CvSeq **) 0 ;
CvMemStorage *arg5 = (CvMemStorage *) 0 ;
CvSURFParams arg6 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *vptr3 ;
CvSeq *buffer3 ;
void *vptr4 ;
CvSeq *buffer4 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvExtractSURF",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvSeq, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvSeq *) vptr3;
arg3=&buffer3;
}
{
if ((SWIG_ConvertPtr(obj3, &vptr4, SWIGTYPE_p_CvSeq, 1)) == -1){
SWIG_fail;
}
buffer4 = (CvSeq *) vptr4;
arg4=&buffer4;
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMemStorage, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvExtractSURF" "', argument " "5"" of type '" "CvMemStorage *""'");
}
arg5 = reinterpret_cast< CvMemStorage * >(argp5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSURFParams, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvExtractSURF" "', argument " "6"" of type '" "CvSURFParams""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvExtractSURF" "', argument " "6"" of type '" "CvSURFParams""'");
} else {
CvSURFParams * temp = reinterpret_cast< CvSURFParams * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
cvExtractSURF((void const *)arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvLoadHaarClassifierCascade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
CvSize arg2 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
void *argp2 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvHaarClassifierCascade *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvLoadHaarClassifierCascade",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvLoadHaarClassifierCascade" "', argument " "1"" of type '" "char const *""'");
}
arg1 = reinterpret_cast< char * >(buf1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvLoadHaarClassifierCascade" "', argument " "2"" of type '" "CvSize""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvLoadHaarClassifierCascade" "', argument " "2"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
try {
result = (CvHaarClassifierCascade *)cvLoadHaarClassifierCascade((char const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarClassifierCascade, SWIG_POINTER_OWN | 0 );
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return resultobj;
fail:
if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
return NULL;
}
SWIGINTERN PyObject *_wrap_cvSetImagesForHaarClassifierCascade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
double arg5 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
double val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:cvSetImagesForHaarClassifierCascade",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvSetImagesForHaarClassifierCascade" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvSetImagesForHaarClassifierCascade" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
{
try {
cvSetImagesForHaarClassifierCascade(arg1,(void const *)arg2,(void const *)arg3,(void const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRunHaarClassifierCascade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ;
CvPoint arg2 ;
int arg3 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvRunHaarClassifierCascade",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRunHaarClassifierCascade" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'");
}
arg1 = reinterpret_cast< CvHaarClassifierCascade * >(argp1);
{
arg2 = PyObject_to_CvPoint(obj1);
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRunHaarClassifierCascade" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
{
try {
result = (int)cvRunHaarClassifierCascade(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvUndistort2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvUndistort2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvUndistort2" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvUndistort2" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
cvUndistort2((void const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitUndistortMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
bool freearg3 = false ;
bool freearg4 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvInitUndistortMap",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitUndistortMap" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitUndistortMap" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
{
try {
cvInitUndistortMap((CvMat const *)arg1,(CvMat const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitUndistortRectifyMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvArr *arg5 = (CvArr *) 0 ;
CvArr *arg6 = (CvArr *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
bool freearg5 = false ;
bool freearg6 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvInitUndistortRectifyMap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitUndistortRectifyMap" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitUndistortRectifyMap" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvInitUndistortRectifyMap" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvInitUndistortRectifyMap" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
arg5 = PyObject_to_CvArr(obj4, &freearg5);
}
{
arg6 = PyObject_to_CvArr(obj5, &freearg6);
}
{
try {
cvInitUndistortRectifyMap((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return resultobj;
fail:
{
if(arg5!=NULL && freearg5){
cvReleaseData( arg5 );
cvFree(&(arg5));
}
}
{
if(arg6!=NULL && freearg6){
cvReleaseData( arg6 );
cvFree(&(arg6));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvUndistortPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OO:cvUndistortPoints",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvUndistortPoints" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvUndistortPoints" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvUndistortPoints" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvUndistortPoints" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvUndistortPoints" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvUndistortPoints" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
}
{
try {
cvUndistortPoints((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRodrigues2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvRodrigues2",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRodrigues2" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRodrigues2" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (obj2) {
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRodrigues2" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
}
{
try {
result = (int)cvRodrigues2((CvMat const *)arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindHomography(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
int arg4 = (int) 0 ;
double arg5 = (double) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOO:cvFindHomography",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindHomography" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindHomography" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindHomography" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvFindHomography" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindHomography" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFindHomography" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
}
{
try {
result = (int)cvFindHomography((CvMat const *)arg1,(CvMat const *)arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRQDecomp3x3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) NULL ;
CvMat *arg5 = (CvMat *) NULL ;
CvMat *arg6 = (CvMat *) NULL ;
CvPoint3D64f *arg7 = (CvPoint3D64f *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOO:cvRQDecomp3x3",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRQDecomp3x3" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRQDecomp3x3" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRQDecomp3x3" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvRQDecomp3x3" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvRQDecomp3x3" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvRQDecomp3x3" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
}
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvRQDecomp3x3" "', argument " "7"" of type '" "CvPoint3D64f *""'");
}
arg7 = reinterpret_cast< CvPoint3D64f * >(argp7);
}
{
try {
cvRQDecomp3x3((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDecomposeProjectionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) NULL ;
CvMat *arg6 = (CvMat *) NULL ;
CvMat *arg7 = (CvMat *) NULL ;
CvPoint3D64f *arg8 = (CvPoint3D64f *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO|OOOO:cvDecomposeProjectionMatrix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvDecomposeProjectionMatrix" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvDecomposeProjectionMatrix" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvDecomposeProjectionMatrix" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvDecomposeProjectionMatrix" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvDecomposeProjectionMatrix" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvDecomposeProjectionMatrix" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
}
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvDecomposeProjectionMatrix" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvPoint3D64f, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvDecomposeProjectionMatrix" "', argument " "8"" of type '" "CvPoint3D64f *""'");
}
arg8 = reinterpret_cast< CvPoint3D64f * >(argp8);
}
{
try {
cvDecomposeProjectionMatrix((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalcMatMulDeriv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvCalcMatMulDeriv",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcMatMulDeriv" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalcMatMulDeriv" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcMatMulDeriv" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcMatMulDeriv" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
cvCalcMatMulDeriv((CvMat const *)arg1,(CvMat const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvComposeRT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvMat *arg7 = (CvMat *) 0 ;
CvMat *arg8 = (CvMat *) 0 ;
CvMat *arg9 = (CvMat *) 0 ;
CvMat *arg10 = (CvMat *) 0 ;
CvMat *arg11 = (CvMat *) 0 ;
CvMat *arg12 = (CvMat *) 0 ;
CvMat *arg13 = (CvMat *) 0 ;
CvMat *arg14 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
void *argp9 = 0 ;
int res9 = 0 ;
void *argp10 = 0 ;
int res10 = 0 ;
void *argp11 = 0 ;
int res11 = 0 ;
void *argp12 = 0 ;
int res12 = 0 ;
void *argp13 = 0 ;
int res13 = 0 ;
void *argp14 = 0 ;
int res14 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
PyObject * obj13 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OOOOOOOO:cvComposeRT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvComposeRT" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvComposeRT" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvComposeRT" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvComposeRT" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvComposeRT" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvComposeRT" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvComposeRT" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvComposeRT" "', argument " "8"" of type '" "CvMat *""'");
}
arg8 = reinterpret_cast< CvMat * >(argp8);
}
if (obj8) {
res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvComposeRT" "', argument " "9"" of type '" "CvMat *""'");
}
arg9 = reinterpret_cast< CvMat * >(argp9);
}
if (obj9) {
res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res10)) {
SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "cvComposeRT" "', argument " "10"" of type '" "CvMat *""'");
}
arg10 = reinterpret_cast< CvMat * >(argp10);
}
if (obj10) {
res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res11)) {
SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvComposeRT" "', argument " "11"" of type '" "CvMat *""'");
}
arg11 = reinterpret_cast< CvMat * >(argp11);
}
if (obj11) {
res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res12)) {
SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvComposeRT" "', argument " "12"" of type '" "CvMat *""'");
}
arg12 = reinterpret_cast< CvMat * >(argp12);
}
if (obj12) {
res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res13)) {
SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "cvComposeRT" "', argument " "13"" of type '" "CvMat *""'");
}
arg13 = reinterpret_cast< CvMat * >(argp13);
}
if (obj13) {
res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res14)) {
SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "cvComposeRT" "', argument " "14"" of type '" "CvMat *""'");
}
arg14 = reinterpret_cast< CvMat * >(argp14);
}
{
try {
cvComposeRT((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvProjectPoints2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvMat *arg7 = (CvMat *) NULL ;
CvMat *arg8 = (CvMat *) NULL ;
CvMat *arg9 = (CvMat *) NULL ;
CvMat *arg10 = (CvMat *) NULL ;
CvMat *arg11 = (CvMat *) NULL ;
double arg12 = (double) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
void *argp9 = 0 ;
int res9 = 0 ;
void *argp10 = 0 ;
int res10 = 0 ;
void *argp11 = 0 ;
int res11 = 0 ;
double val12 ;
int ecode12 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OOOOOO:cvProjectPoints2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvProjectPoints2" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvProjectPoints2" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvProjectPoints2" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvProjectPoints2" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvProjectPoints2" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvProjectPoints2" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvProjectPoints2" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvProjectPoints2" "', argument " "8"" of type '" "CvMat *""'");
}
arg8 = reinterpret_cast< CvMat * >(argp8);
}
if (obj8) {
res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvProjectPoints2" "', argument " "9"" of type '" "CvMat *""'");
}
arg9 = reinterpret_cast< CvMat * >(argp9);
}
if (obj9) {
res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res10)) {
SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "cvProjectPoints2" "', argument " "10"" of type '" "CvMat *""'");
}
arg10 = reinterpret_cast< CvMat * >(argp10);
}
if (obj10) {
res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res11)) {
SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvProjectPoints2" "', argument " "11"" of type '" "CvMat *""'");
}
arg11 = reinterpret_cast< CvMat * >(argp11);
}
if (obj11) {
ecode12 = SWIG_AsVal_double(obj11, &val12);
if (!SWIG_IsOK(ecode12)) {
SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "cvProjectPoints2" "', argument " "12"" of type '" "double""'");
}
arg12 = static_cast< double >(val12);
}
{
try {
cvProjectPoints2((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindExtrinsicCameraParams2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvFindExtrinsicCameraParams2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFindExtrinsicCameraParams2" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
try {
cvFindExtrinsicCameraParams2((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvInitIntrinsicParams2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvSize arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
double arg6 = (double) 1. ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
double val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvInitIntrinsicParams2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitIntrinsicParams2D" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitIntrinsicParams2D" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvInitIntrinsicParams2D" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvInitIntrinsicParams2D" "', argument " "4"" of type '" "CvSize""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvInitIntrinsicParams2D" "', argument " "4"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvInitIntrinsicParams2D" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
if (obj5) {
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvInitIntrinsicParams2D" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
}
{
try {
cvInitIntrinsicParams2D((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindChessboardCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *arg1 = (void *) 0 ;
CvSize arg2 ;
CvPoint2D32f *arg3 = (CvPoint2D32f *) 0 ;
int *arg4 = (int *) NULL ;
int arg5 = (int) 1+2 ;
int res1 ;
CvSize *pattern_size2 ;
CvPoint2D32f *tmp_corners2 ;
int tmp_ncorners2 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OO|O:cvFindChessboardCorners",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindChessboardCorners" "', argument " "1"" of type '" "void const *""'");
}
{
void * vptr;
if( SWIG_ConvertPtr(obj1, &vptr, SWIGTYPE_p_CvSize, SWIG_POINTER_EXCEPTION ) == -1){
return NULL;
}
pattern_size2=(CvSize *)vptr;
tmp_ncorners2 = pattern_size2->width*pattern_size2->height;
tmp_corners2 = (CvPoint2D32f *) malloc(sizeof(CvPoint2D32f)*tmp_ncorners2);
arg2 = *pattern_size2;
arg3 = tmp_corners2;
arg4 = &tmp_ncorners2;
}
if (obj2) {
ecode5 = SWIG_AsVal_int(obj2, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindChessboardCorners" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
}
{
try {
result = (int)cvFindChessboardCorners((void const *)arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New ( tmp_ncorners2 );
/* extract all the corner values of the result, and add it to the
final resulting list */
for (i = 0; i < tmp_ncorners2; i++) {
CvPoint2D32f * pt = new CvPoint2D32f;
pt->x = tmp_corners2[i].x;
pt->y = tmp_corners2[i].y;
PyList_SetItem (to_add, i,
SWIG_NewPointerObj( pt, SWIGTYPE_p_CvPoint2D32f, 0));
}
resultobj = SWIG_AppendResult( resultobj, &to_add, 1);
free(tmp_corners2);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvDrawChessboardCorners(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvSize arg2 ;
CvPoint2D32f *arg3 = (CvPoint2D32f *) 0 ;
int arg4 ;
int arg5 ;
bool freearg1 = false ;
void *argp2 ;
int res2 = 0 ;
int cornersCount3 ;
CvPoint2D32f *corners3 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvDrawChessboardCorners",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvDrawChessboardCorners" "', argument " "2"" of type '" "CvSize""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvDrawChessboardCorners" "', argument " "2"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
{
int i;
if(!PyList_Check(obj2)){
PyErr_SetString(PyExc_TypeError, "Expected a list");
return NULL;
}
/* get the size of the input array */
cornersCount3 = PyList_Size (obj2);
arg4 = cornersCount3;
/* allocate the needed memory */
corners3 = (CvPoint2D32f *)malloc (arg4 * sizeof (CvPoint2D32f));
arg3 = corners3;
/* the size of the array for the C call */
/* extract all the points values from the list */
for (i = 0; i < arg4; i++) {
PyObject *item = PyList_GetItem (obj2, i);
void *vptr;
SWIG_Python_ConvertPtr (item, &vptr,
SWIGTYPE_p_CvPoint2D32f,
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *) vptr;;
arg3 [i].x = p->x;
arg3 [i].y = p->y;
}
}
ecode5 = SWIG_AsVal_int(obj3, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvDrawChessboardCorners" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
cvDrawChessboardCorners(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
int i;
PyObject *to_add;
/* create the list to return */
to_add = PyList_New (cornersCount3);
/* extract all the corner values of the result, and add it to the
final resulting list */
for (i = 0; i < cornersCount3; i++) {
PyList_SetItem (to_add, i,
SWIG_NewPointerObj (&(corners3 [i]),
SWIGTYPE_p_CvPoint2D32f, 0));
}
resultobj = SWIG_AppendResult( resultobj, &to_add, 1);
}
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalibrateCamera2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvSize arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvMat *arg7 = (CvMat *) NULL ;
CvMat *arg8 = (CvMat *) NULL ;
int arg9 = (int) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
int val9 ;
int ecode9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|OOO:cvCalibrateCamera2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalibrateCamera2" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalibrateCamera2" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalibrateCamera2" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalibrateCamera2" "', argument " "4"" of type '" "CvSize""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalibrateCamera2" "', argument " "4"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCalibrateCamera2" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvCalibrateCamera2" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalibrateCamera2" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvCalibrateCamera2" "', argument " "8"" of type '" "CvMat *""'");
}
arg8 = reinterpret_cast< CvMat * >(argp8);
}
if (obj8) {
ecode9 = SWIG_AsVal_int(obj8, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvCalibrateCamera2" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
}
{
try {
cvCalibrateCamera2((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCalibrationMatrixValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvSize arg2 ;
double arg3 = (double) 0 ;
double arg4 = (double) 0 ;
double *arg5 = (double *) NULL ;
double *arg6 = (double *) NULL ;
double *arg7 = (double *) NULL ;
CvPoint2D64f *arg8 = (CvPoint2D64f *) NULL ;
double *arg9 = (double *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 ;
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
double val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
void *argp9 = 0 ;
int res9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO|OOOOOOO:cvCalibrationMatrixValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalibrationMatrixValues" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCalibrationMatrixValues" "', argument " "2"" of type '" "CvSize""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalibrationMatrixValues" "', argument " "2"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp2);
arg2 = *temp;
if (SWIG_IsNewObj(res2)) delete temp;
}
}
if (obj2) {
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCalibrationMatrixValues" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_double(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCalibrationMatrixValues" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
}
if (obj4) {
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCalibrationMatrixValues" "', argument " "5"" of type '" "double *""'");
}
arg5 = reinterpret_cast< double * >(argp5);
}
if (obj5) {
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvCalibrationMatrixValues" "', argument " "6"" of type '" "double *""'");
}
arg6 = reinterpret_cast< double * >(argp6);
}
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalibrationMatrixValues" "', argument " "7"" of type '" "double *""'");
}
arg7 = reinterpret_cast< double * >(argp7);
}
if (obj7) {
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvPoint2D64f, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvCalibrationMatrixValues" "', argument " "8"" of type '" "CvPoint2D64f *""'");
}
arg8 = reinterpret_cast< CvPoint2D64f * >(argp8);
}
if (obj8) {
res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvCalibrationMatrixValues" "', argument " "9"" of type '" "double *""'");
}
arg9 = reinterpret_cast< double * >(argp9);
}
{
try {
cvCalibrationMatrixValues((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStereoCalibrate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvMat *arg7 = (CvMat *) 0 ;
CvMat *arg8 = (CvMat *) 0 ;
CvSize arg9 ;
CvMat *arg10 = (CvMat *) 0 ;
CvMat *arg11 = (CvMat *) 0 ;
CvMat *arg12 = (CvMat *) 0 ;
CvMat *arg13 = (CvMat *) 0 ;
CvTermCriteria arg14 = (CvTermCriteria) cvTermCriteria( 1 +2,30,1e-6) ;
int arg15 = (int) 256 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
void *argp9 ;
int res9 = 0 ;
void *argp10 = 0 ;
int res10 = 0 ;
void *argp11 = 0 ;
int res11 = 0 ;
void *argp12 = 0 ;
int res12 = 0 ;
void *argp13 = 0 ;
int res13 = 0 ;
void *argp14 ;
int res14 = 0 ;
int val15 ;
int ecode15 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
PyObject * obj13 = 0 ;
PyObject * obj14 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO|OOOO:cvStereoCalibrate",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStereoCalibrate" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStereoCalibrate" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvStereoCalibrate" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStereoCalibrate" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvStereoCalibrate" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvStereoCalibrate" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvStereoCalibrate" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvStereoCalibrate" "', argument " "8"" of type '" "CvMat *""'");
}
arg8 = reinterpret_cast< CvMat * >(argp8);
{
res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvStereoCalibrate" "', argument " "9"" of type '" "CvSize""'");
}
if (!argp9) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvStereoCalibrate" "', argument " "9"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp9);
arg9 = *temp;
if (SWIG_IsNewObj(res9)) delete temp;
}
}
res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res10)) {
SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "cvStereoCalibrate" "', argument " "10"" of type '" "CvMat *""'");
}
arg10 = reinterpret_cast< CvMat * >(argp10);
res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res11)) {
SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvStereoCalibrate" "', argument " "11"" of type '" "CvMat *""'");
}
arg11 = reinterpret_cast< CvMat * >(argp11);
if (obj11) {
res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res12)) {
SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvStereoCalibrate" "', argument " "12"" of type '" "CvMat *""'");
}
arg12 = reinterpret_cast< CvMat * >(argp12);
}
if (obj12) {
res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res13)) {
SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "cvStereoCalibrate" "', argument " "13"" of type '" "CvMat *""'");
}
arg13 = reinterpret_cast< CvMat * >(argp13);
}
if (obj13) {
{
res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res14)) {
SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "cvStereoCalibrate" "', argument " "14"" of type '" "CvTermCriteria""'");
}
if (!argp14) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvStereoCalibrate" "', argument " "14"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp14);
arg14 = *temp;
if (SWIG_IsNewObj(res14)) delete temp;
}
}
}
if (obj14) {
ecode15 = SWIG_AsVal_int(obj14, &val15);
if (!SWIG_IsOK(ecode15)) {
SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "cvStereoCalibrate" "', argument " "15"" of type '" "int""'");
}
arg15 = static_cast< int >(val15);
}
{
try {
cvStereoCalibrate((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStereoRectify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
CvSize arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
CvMat *arg7 = (CvMat *) 0 ;
CvMat *arg8 = (CvMat *) 0 ;
CvMat *arg9 = (CvMat *) 0 ;
CvMat *arg10 = (CvMat *) 0 ;
CvMat *arg11 = (CvMat *) 0 ;
CvMat *arg12 = (CvMat *) 0 ;
int arg13 = (int) 1024 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
void *argp8 = 0 ;
int res8 = 0 ;
void *argp9 = 0 ;
int res9 = 0 ;
void *argp10 = 0 ;
int res10 = 0 ;
void *argp11 = 0 ;
int res11 = 0 ;
void *argp12 = 0 ;
int res12 = 0 ;
int val13 ;
int ecode13 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
PyObject * obj10 = 0 ;
PyObject * obj11 = 0 ;
PyObject * obj12 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO|OO:cvStereoRectify",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStereoRectify" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStereoRectify" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvStereoRectify" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStereoRectify" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvStereoRectify" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvStereoRectify" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvStereoRectify" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvStereoRectify" "', argument " "7"" of type '" "CvMat const *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res8)) {
SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvStereoRectify" "', argument " "8"" of type '" "CvMat *""'");
}
arg8 = reinterpret_cast< CvMat * >(argp8);
res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res9)) {
SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvStereoRectify" "', argument " "9"" of type '" "CvMat *""'");
}
arg9 = reinterpret_cast< CvMat * >(argp9);
res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res10)) {
SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "cvStereoRectify" "', argument " "10"" of type '" "CvMat *""'");
}
arg10 = reinterpret_cast< CvMat * >(argp10);
res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res11)) {
SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvStereoRectify" "', argument " "11"" of type '" "CvMat *""'");
}
arg11 = reinterpret_cast< CvMat * >(argp11);
if (obj11) {
res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res12)) {
SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvStereoRectify" "', argument " "12"" of type '" "CvMat *""'");
}
arg12 = reinterpret_cast< CvMat * >(argp12);
}
if (obj12) {
ecode13 = SWIG_AsVal_int(obj12, &val13);
if (!SWIG_IsOK(ecode13)) {
SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "cvStereoRectify" "', argument " "13"" of type '" "int""'");
}
arg13 = static_cast< int >(val13);
}
{
try {
cvStereoRectify((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,(CvMat const *)arg6,(CvMat const *)arg7,arg8,arg9,arg10,arg11,arg12,arg13);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvStereoRectifyUncalibrated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvSize arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
double arg7 = (double) 5 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
double val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO|O:cvStereoRectifyUncalibrated",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvStereoRectifyUncalibrated" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvStereoRectifyUncalibrated" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvStereoRectifyUncalibrated" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvStereoRectifyUncalibrated" "', argument " "4"" of type '" "CvSize""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvStereoRectifyUncalibrated" "', argument " "4"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvStereoRectifyUncalibrated" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvStereoRectifyUncalibrated" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
if (obj6) {
ecode7 = SWIG_AsVal_double(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvStereoRectifyUncalibrated" "', argument " "7"" of type '" "double""'");
}
arg7 = static_cast< double >(val7);
}
{
try {
result = (int)cvStereoRectifyUncalibrated((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvCreatePOSITObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPoint3D32f *arg1 = (CvPoint3D32f *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPOSITObject *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreatePOSITObject",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreatePOSITObject" "', argument " "1"" of type '" "CvPoint3D32f *""'");
}
arg1 = reinterpret_cast< CvPoint3D32f * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreatePOSITObject" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvPOSITObject *)cvCreatePOSITObject(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPOSITObject, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvPOSIT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvPOSITObject *arg1 = (CvPOSITObject *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
double arg3 ;
CvTermCriteria arg4 ;
CvMatr32f arg5 = (CvMatr32f) 0 ;
CvVect32f arg6 = (CvVect32f) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
void *argp4 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:cvPOSIT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvPOSITObject, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvPOSIT" "', argument " "1"" of type '" "CvPOSITObject *""'");
}
arg1 = reinterpret_cast< CvPOSITObject * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvPOSIT" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
ecode3 = SWIG_AsVal_double(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvPOSIT" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvPOSIT" "', argument " "4"" of type '" "CvTermCriteria""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvPOSIT" "', argument " "4"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvPOSIT" "', argument " "5"" of type '" "CvMatr32f""'");
}
arg5 = reinterpret_cast< CvMatr32f >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvPOSIT" "', argument " "6"" of type '" "CvVect32f""'");
}
arg6 = reinterpret_cast< CvVect32f >(argp6);
{
try {
cvPOSIT(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvRANSACUpdateNumIters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double arg1 ;
double arg2 ;
int arg3 ;
int arg4 ;
double val1 ;
int ecode1 = 0 ;
double val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvRANSACUpdateNumIters",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_double(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRANSACUpdateNumIters" "', argument " "1"" of type '" "double""'");
}
arg1 = static_cast< double >(val1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRANSACUpdateNumIters" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRANSACUpdateNumIters" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvRANSACUpdateNumIters" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
result = (int)cvRANSACUpdateNumIters(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvConvertPointsHomogeneous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvConvertPointsHomogeneous",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvConvertPointsHomogeneous" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvConvertPointsHomogeneous" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
{
try {
cvConvertPointsHomogeneous((CvMat const *)arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindFundamentalMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
int arg4 = (int) 8 ;
double arg5 = (double) 3. ;
double arg6 = (double) 0.99 ;
CvMat *arg7 = (CvMat *) NULL ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
int val4 ;
int ecode4 = 0 ;
double val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO|OOOO:cvFindFundamentalMat",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFindFundamentalMat" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindFundamentalMat" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvFindFundamentalMat" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvFindFundamentalMat" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
if (obj4) {
ecode5 = SWIG_AsVal_double(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvFindFundamentalMat" "', argument " "5"" of type '" "double""'");
}
arg5 = static_cast< double >(val5);
}
if (obj5) {
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFindFundamentalMat" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
}
if (obj6) {
res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvFindFundamentalMat" "', argument " "7"" of type '" "CvMat *""'");
}
arg7 = reinterpret_cast< CvMat * >(argp7);
}
{
try {
result = (int)cvFindFundamentalMat((CvMat const *)arg1,(CvMat const *)arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvComputeCorrespondEpilines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
CvMat *arg3 = (CvMat *) 0 ;
CvMat *arg4 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvComputeCorrespondEpilines",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvComputeCorrespondEpilines" "', argument " "1"" of type '" "CvMat const *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvComputeCorrespondEpilines" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvComputeCorrespondEpilines" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvComputeCorrespondEpilines" "', argument " "4"" of type '" "CvMat *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
cvComputeCorrespondEpilines((CvMat const *)arg1,arg2,(CvMat const *)arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_preFilterType_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterType_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_preFilterType_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->preFilterType = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_preFilterType_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterType_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->preFilterType);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_preFilterSize_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_preFilterSize_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->preFilterSize = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_preFilterSize_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->preFilterSize);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterCap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_preFilterCap_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterCap_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_preFilterCap_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->preFilterCap = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilterCap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_preFilterCap_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterCap_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->preFilterCap);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_SADWindowSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_SADWindowSize_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_SADWindowSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_SADWindowSize_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->SADWindowSize = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_SADWindowSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_SADWindowSize_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_SADWindowSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->SADWindowSize);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_minDisparity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_minDisparity_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_minDisparity_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_minDisparity_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->minDisparity = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_minDisparity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_minDisparity_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_minDisparity_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->minDisparity);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_numberOfDisparities_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_numberOfDisparities_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_numberOfDisparities_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_numberOfDisparities_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->numberOfDisparities = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_numberOfDisparities_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_numberOfDisparities_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_numberOfDisparities_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->numberOfDisparities);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_textureThreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_textureThreshold_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_textureThreshold_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_textureThreshold_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->textureThreshold = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_textureThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_textureThreshold_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_textureThreshold_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->textureThreshold);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_uniquenessRatio_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_uniquenessRatio_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_uniquenessRatio_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_uniquenessRatio_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->uniquenessRatio = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_uniquenessRatio_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_uniquenessRatio_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_uniquenessRatio_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->uniquenessRatio);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_speckleWindowSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_speckleWindowSize_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleWindowSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_speckleWindowSize_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->speckleWindowSize = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_speckleWindowSize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_speckleWindowSize_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleWindowSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->speckleWindowSize);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_speckleRange_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_speckleRange_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleRange_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_speckleRange_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->speckleRange = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_speckleRange_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_speckleRange_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleRange_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (int) ((arg1)->speckleRange);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilteredImg0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_preFilteredImg0_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg0_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoBMState_preFilteredImg0_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->preFilteredImg0 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilteredImg0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_preFilteredImg0_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg0_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (CvMat *) ((arg1)->preFilteredImg0);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilteredImg1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_preFilteredImg1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg1_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoBMState_preFilteredImg1_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->preFilteredImg1 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_preFilteredImg1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_preFilteredImg1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg1_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (CvMat *) ((arg1)->preFilteredImg1);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_slidingSumBuf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoBMState_slidingSumBuf_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_slidingSumBuf_set" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoBMState_slidingSumBuf_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->slidingSumBuf = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoBMState_slidingSumBuf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoBMState_slidingSumBuf_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_slidingSumBuf_get" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
result = (CvMat *) ((arg1)->slidingSumBuf);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvStereoBMState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvStereoBMState")) SWIG_fail;
{
try {
result = (CvStereoBMState *)new CvStereoBMState();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoBMState, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvStereoBMState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState *arg1 = (CvStereoBMState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvStereoBMState",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoBMState, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStereoBMState" "', argument " "1"" of type '" "CvStereoBMState *""'");
}
arg1 = reinterpret_cast< CvStereoBMState * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvStereoBMState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvStereoBMState, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvCreateStereoBMState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 = (int) 0 ;
int arg2 = (int) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvStereoBMState *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"|OO:cvCreateStereoBMState",&obj0,&obj1)) SWIG_fail;
if (obj0) {
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateStereoBMState" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
}
if (obj1) {
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateStereoBMState" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
}
{
try {
result = (CvStereoBMState *)cvCreateStereoBMState(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoBMState, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseStereoBMState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoBMState **arg1 = (CvStereoBMState **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseStereoBMState",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReleaseStereoBMState" "', argument " "1"" of type '" "CvStereoBMState **""'");
}
arg1 = reinterpret_cast< CvStereoBMState ** >(argp1);
{
try {
cvReleaseStereoBMState(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindStereoCorrespondenceBM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvStereoBMState *arg4 = (CvStereoBMState *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:cvFindStereoCorrespondenceBM",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvStereoBMState, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindStereoCorrespondenceBM" "', argument " "4"" of type '" "CvStereoBMState *""'");
}
arg4 = reinterpret_cast< CvStereoBMState * >(argp4);
{
try {
cvFindStereoCorrespondenceBM((void const *)arg1,(void const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_Ithreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_Ithreshold_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_Ithreshold_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_Ithreshold_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->Ithreshold = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_Ithreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_Ithreshold_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_Ithreshold_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->Ithreshold);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_interactionRadius_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_interactionRadius_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_interactionRadius_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_interactionRadius_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->interactionRadius = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_interactionRadius_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_interactionRadius_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_interactionRadius_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->interactionRadius);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_K_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_K_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_K_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_K_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->K = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_K_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_K_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_K_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (float) ((arg1)->K);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState__lambda_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState__lambda_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState__lambda_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState__lambda_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->lambda = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState__lambda_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState__lambda_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState__lambda_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (float) ((arg1)->lambda);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_lambda1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_lambda1_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda1_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_lambda1_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->lambda1 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_lambda1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_lambda1_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda1_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (float) ((arg1)->lambda1);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_lambda2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
float arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
float val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_lambda2_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda2_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_float(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_lambda2_set" "', argument " "2"" of type '" "float""'");
}
arg2 = static_cast< float >(val2);
if (arg1) (arg1)->lambda2 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_lambda2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_lambda2_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda2_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (float) ((arg1)->lambda2);
resultobj = SWIG_From_float(static_cast< float >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_occlusionCost_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_occlusionCost_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_occlusionCost_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_occlusionCost_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->occlusionCost = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_occlusionCost_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_occlusionCost_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_occlusionCost_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->occlusionCost);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_minDisparity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_minDisparity_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_minDisparity_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_minDisparity_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->minDisparity = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_minDisparity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_minDisparity_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_minDisparity_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->minDisparity);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_numberOfDisparities_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_numberOfDisparities_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_numberOfDisparities_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_numberOfDisparities_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->numberOfDisparities = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_numberOfDisparities_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_numberOfDisparities_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_numberOfDisparities_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->numberOfDisparities);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_maxIters_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_maxIters_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_maxIters_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_maxIters_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->maxIters = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_maxIters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_maxIters_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_maxIters_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (int) ((arg1)->maxIters);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_left_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_left_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_left_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_left_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->left = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_left_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_left_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->left);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_right_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_right_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_right_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_right_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->right = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_right_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_right_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->right);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_dispLeft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_dispLeft_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispLeft_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_dispLeft_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->dispLeft = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_dispLeft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_dispLeft_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispLeft_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->dispLeft);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_dispRight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_dispRight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispRight_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_dispRight_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->dispRight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_dispRight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_dispRight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispRight_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->dispRight);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_ptrLeft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_ptrLeft_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrLeft_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_ptrLeft_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->ptrLeft = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_ptrLeft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_ptrLeft_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrLeft_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->ptrLeft);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_ptrRight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_ptrRight_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrRight_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_ptrRight_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->ptrRight = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_ptrRight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_ptrRight_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrRight_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->ptrRight);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_vtxBuf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_vtxBuf_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_vtxBuf_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_vtxBuf_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->vtxBuf = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_vtxBuf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_vtxBuf_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_vtxBuf_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->vtxBuf);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_edgeBuf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvStereoGCState_edgeBuf_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_edgeBuf_set" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStereoGCState_edgeBuf_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->edgeBuf = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvStereoGCState_edgeBuf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvStereoGCState_edgeBuf_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_edgeBuf_get" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
result = (CvMat *) ((arg1)->edgeBuf);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvStereoGCState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvStereoGCState")) SWIG_fail;
{
try {
result = (CvStereoGCState *)new CvStereoGCState();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoGCState, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvStereoGCState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState *arg1 = (CvStereoGCState *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvStereoGCState",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvStereoGCState, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStereoGCState" "', argument " "1"" of type '" "CvStereoGCState *""'");
}
arg1 = reinterpret_cast< CvStereoGCState * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvStereoGCState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvStereoGCState, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_cvCreateStereoGCState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvStereoGCState *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:cvCreateStereoGCState",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateStereoGCState" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateStereoGCState" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvStereoGCState *)cvCreateStereoGCState(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoGCState, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReleaseStereoGCState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvStereoGCState **arg1 = (CvStereoGCState **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:cvReleaseStereoGCState",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReleaseStereoGCState" "', argument " "1"" of type '" "CvStereoGCState **""'");
}
arg1 = reinterpret_cast< CvStereoGCState ** >(argp1);
{
try {
cvReleaseStereoGCState(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_cvFindStereoCorrespondenceGC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvArr *arg3 = (CvArr *) 0 ;
CvArr *arg4 = (CvArr *) 0 ;
CvStereoGCState *arg5 = (CvStereoGCState *) 0 ;
int arg6 = (int) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
bool freearg3 = false ;
bool freearg4 = false ;
void *argp5 = 0 ;
int res5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO|O:cvFindStereoCorrespondenceGC",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
{
arg3 = PyObject_to_CvArr(obj2, &freearg3);
}
{
arg4 = PyObject_to_CvArr(obj3, &freearg4);
}
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvStereoGCState, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvFindStereoCorrespondenceGC" "', argument " "5"" of type '" "CvStereoGCState *""'");
}
arg5 = reinterpret_cast< CvStereoGCState * >(argp5);
if (obj5) {
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvFindStereoCorrespondenceGC" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
}
{
try {
cvFindStereoCorrespondenceGC((void const *)arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
{
if(arg3!=NULL && freearg3){
cvReleaseData( arg3 );
cvFree(&(arg3));
}
}
{
if(arg4!=NULL && freearg4){
cvReleaseData( arg4 );
cvFree(&(arg4));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_cvReprojectImageTo3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvArr *arg1 = (CvArr *) 0 ;
CvArr *arg2 = (CvArr *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
bool freearg1 = false ;
bool freearg2 = false ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:cvReprojectImageTo3D",&obj0,&obj1,&obj2)) SWIG_fail;
{
arg1 = PyObject_to_CvArr(obj0, &freearg1);
}
{
arg2 = PyObject_to_CvArr(obj1, &freearg2);
}
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvReprojectImageTo3D" "', argument " "3"" of type '" "CvMat const *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
cvReprojectImageTo3D((void const *)arg1,arg2,(CvMat const *)arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return resultobj;
fail:
{
if(arg1!=NULL && freearg1){
cvReleaseData( arg1 );
cvFree(&(arg1));
}
}
{
if(arg2!=NULL && freearg2){
cvReleaseData( arg2 );
cvFree(&(arg2));
}
}
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvBaseImageFilter")) SWIG_fail;
{
try {
result = (CvBaseImageFilter *)new CvBaseImageFilter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int arg7 ;
CvScalar arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
CvBaseImageFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_CvBaseImageFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBaseImageFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBaseImageFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBaseImageFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBaseImageFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvBaseImageFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
arg8 = PyObject_to_CvScalar( obj7 );
}
{
try {
result = (CvBaseImageFilter *)new CvBaseImageFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvBaseImageFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvBaseImageFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBaseImageFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBaseImageFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBaseImageFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBaseImageFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvBaseImageFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
result = (CvBaseImageFilter *)new CvBaseImageFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvBaseImageFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvBaseImageFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBaseImageFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBaseImageFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBaseImageFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBaseImageFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
{
try {
result = (CvBaseImageFilter *)new CvBaseImageFilter(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvBaseImageFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvBaseImageFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBaseImageFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBaseImageFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBaseImageFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBaseImageFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBaseImageFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
try {
result = (CvBaseImageFilter *)new CvBaseImageFilter(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBaseImageFilter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[9];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 8); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvBaseImageFilter__SWIG_0(self, args);
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvBaseImageFilter__SWIG_4(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvBaseImageFilter__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvBaseImageFilter__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[7] );
}
if (_v) {
return _wrap_new_CvBaseImageFilter__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvBaseImageFilter'.\n"
" Possible C/C++ prototypes are:\n"
" CvBaseImageFilter()\n"
" CvBaseImageFilter(int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" CvBaseImageFilter(int,int,int,bool,CvSize,CvPoint,int)\n"
" CvBaseImageFilter(int,int,int,bool,CvSize,CvPoint)\n"
" CvBaseImageFilter(int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvBaseImageFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvBaseImageFilter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBaseImageFilter" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvBaseImageFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_init" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBaseImageFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBaseImageFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBaseImageFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBaseImageFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvBaseImageFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvBaseImageFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_init" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBaseImageFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBaseImageFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBaseImageFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBaseImageFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvBaseImageFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvBaseImageFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_init" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBaseImageFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBaseImageFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBaseImageFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBaseImageFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvBaseImageFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_init" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBaseImageFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBaseImageFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBaseImageFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBaseImageFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBaseImageFilter_init__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBaseImageFilter_init__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvBaseImageFilter_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvBaseImageFilter_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvBaseImageFilter_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvBaseImageFilter *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvBaseImageFilter *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvBaseImageFilter *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvBaseImageFilter *,int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_clear" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_process__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvRect arg4 ;
CvPoint arg5 ;
int arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvBaseImageFilter_process",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_process" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBaseImageFilter_process" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBaseImageFilter_process" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
arg5 = PyObject_to_CvPoint(obj4);
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvBaseImageFilter_process" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
result = (int)(arg1)->process((CvMat const *)arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_process__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvRect arg4 ;
CvPoint arg5 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvBaseImageFilter_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_process" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBaseImageFilter_process" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBaseImageFilter_process" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
arg5 = PyObject_to_CvPoint(obj4);
}
{
try {
result = (int)(arg1)->process((CvMat const *)arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_process__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
CvRect arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvBaseImageFilter_process",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_process" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBaseImageFilter_process" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBaseImageFilter_process" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvRect, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBaseImageFilter_process" "', argument " "4"" of type '" "CvRect""'");
} else {
CvRect * temp = reinterpret_cast< CvRect * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
try {
result = (int)(arg1)->process((CvMat const *)arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_process__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
CvMat *arg3 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvBaseImageFilter_process",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_process" "', argument " "1"" of type '" "CvBaseImageFilter *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBaseImageFilter_process" "', argument " "2"" of type '" "CvMat const *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBaseImageFilter_process" "', argument " "3"" of type '" "CvMat *""'");
}
arg3 = reinterpret_cast< CvMat * >(argp3);
{
try {
result = (int)(arg1)->process((CvMat const *)arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_process(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[7];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 6); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBaseImageFilter_process__SWIG_3(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CvRect, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBaseImageFilter_process__SWIG_2(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CvRect, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBaseImageFilter_process__SWIG_1(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBaseImageFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CvRect, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvBaseImageFilter_process__SWIG_0(self, args);
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvBaseImageFilter_process'.\n"
" Possible C/C++ prototypes are:\n"
" process(CvBaseImageFilter *,CvMat const *,CvMat *,CvRect,CvPoint,int)\n"
" process(CvBaseImageFilter *,CvMat const *,CvMat *,CvRect,CvPoint)\n"
" process(CvBaseImageFilter *,CvMat const *,CvMat *,CvRect)\n"
" process(CvBaseImageFilter *,CvMat const *,CvMat *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_src_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_src_type",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_src_type" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (int)((CvBaseImageFilter const *)arg1)->get_src_type();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_dst_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_dst_type",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_dst_type" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (int)((CvBaseImageFilter const *)arg1)->get_dst_type();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_work_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_work_type",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_work_type" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (int)((CvBaseImageFilter const *)arg1)->get_work_type();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_kernel_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSize result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_kernel_size",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_kernel_size" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = ((CvBaseImageFilter const *)arg1)->get_kernel_size();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvSize(static_cast< const CvSize& >(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_anchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_anchor",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_anchor" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = ((CvBaseImageFilter const *)arg1)->get_anchor();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj((new CvPoint(static_cast< const CvPoint& >(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_width",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_width" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (int)((CvBaseImageFilter const *)arg1)->get_width();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_x_filter_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRowFilterFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_x_filter_func",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_x_filter_func" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (CvRowFilterFunc)((CvBaseImageFilter const *)arg1)->get_x_filter_func();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBaseImageFilter_get_y_filter_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBaseImageFilter *arg1 = (CvBaseImageFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvColumnFilterFunc result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBaseImageFilter_get_y_filter_func",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBaseImageFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBaseImageFilter_get_y_filter_func" "', argument " "1"" of type '" "CvBaseImageFilter const *""'");
}
arg1 = reinterpret_cast< CvBaseImageFilter * >(argp1);
{
try {
result = (CvColumnFilterFunc)((CvBaseImageFilter const *)arg1)->get_y_filter_func();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvBaseImageFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvBaseImageFilter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSepFilter")) SWIG_fail;
{
try {
result = (CvSepFilter *)new CvSepFilter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSepFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
int arg7 ;
CvScalar arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
CvSepFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_CvSepFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSepFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSepFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvSepFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSepFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvSepFilter" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvSepFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
arg8 = PyObject_to_CvScalar( obj7 );
}
{
try {
result = (CvSepFilter *)new CvSepFilter(arg1,arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSepFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
int arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvSepFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvSepFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSepFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSepFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvSepFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSepFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvSepFilter" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvSepFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
result = (CvSepFilter *)new CvSepFilter(arg1,arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSepFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvSepFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvSepFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSepFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSepFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvSepFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSepFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvSepFilter" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
{
try {
result = (CvSepFilter *)new CvSepFilter(arg1,arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSepFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvMat *arg5 = (CvMat *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvSepFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvSepFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSepFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSepFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvSepFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSepFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvSepFilter" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
try {
result = (CvSepFilter *)new CvSepFilter(arg1,arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSepFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSepFilter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[9];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 8); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvSepFilter__SWIG_0(self, args);
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvSepFilter__SWIG_4(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvSepFilter__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvSepFilter__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[7] );
}
if (_v) {
return _wrap_new_CvSepFilter__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvSepFilter'.\n"
" Possible C/C++ prototypes are:\n"
" CvSepFilter()\n"
" CvSepFilter(int,int,int,CvMat const *,CvMat const *,CvPoint,int,CvScalar)\n"
" CvSepFilter(int,int,int,CvMat const *,CvMat const *,CvPoint,int)\n"
" CvSepFilter(int,int,int,CvMat const *,CvMat const *,CvPoint)\n"
" CvSepFilter(int,int,int,CvMat const *,CvMat const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSepFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSepFilter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSepFilter" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSepFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSepFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_deriv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
int arg6 ;
int arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvSepFilter_init_deriv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_deriv" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init_deriv" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_deriv" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_deriv" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init_deriv" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvSepFilter_init_deriv" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSepFilter_init_deriv" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSepFilter_init_deriv" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init_deriv(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_deriv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
int arg6 ;
int arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvSepFilter_init_deriv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_deriv" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init_deriv" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_deriv" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_deriv" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init_deriv" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvSepFilter_init_deriv" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSepFilter_init_deriv" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
(arg1)->init_deriv(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_deriv(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[9];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 8); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_deriv__SWIG_1(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_deriv__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvSepFilter_init_deriv'.\n"
" Possible C/C++ prototypes are:\n"
" init_deriv(CvSepFilter *,int,int,int,int,int,int,int)\n"
" init_deriv(CvSepFilter *,int,int,int,int,int,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_gaussian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
double arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
double val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvSepFilter_init_gaussian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_gaussian" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init_gaussian" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_gaussian" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_gaussian" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init_gaussian" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_double(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvSepFilter_init_gaussian" "', argument " "6"" of type '" "double""'");
}
arg6 = static_cast< double >(val6);
{
try {
(arg1)->init_gaussian(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSepFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSepFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvSepFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSepFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvSepFilter_init__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvSepFilter_init__SWIG_7(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvSepFilter_init__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvSepFilter_init__SWIG_6(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init__SWIG_5(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvSepFilter_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSepFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvSepFilter_init__SWIG_4(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvSepFilter_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvSepFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint,int,CvScalar)\n"
" init(CvSepFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint,int)\n"
" init(CvSepFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint)\n"
" init(CvSepFilter *,int,int,int,CvMat const *,CvMat const *)\n"
" init(CvSepFilter *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvSepFilter *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvSepFilter *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvSepFilter *,int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_clear" "', argument " "1"" of type '" "CvSepFilter *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_get_x_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_get_x_kernel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_get_x_kernel" "', argument " "1"" of type '" "CvSepFilter const *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
result = (CvMat *)((CvSepFilter const *)arg1)->get_x_kernel();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_get_y_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_get_y_kernel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_get_y_kernel" "', argument " "1"" of type '" "CvSepFilter const *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
result = (CvMat *)((CvSepFilter const *)arg1)->get_y_kernel();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_get_x_kernel_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_get_x_kernel_flags",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_get_x_kernel_flags" "', argument " "1"" of type '" "CvSepFilter const *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
result = (int)((CvSepFilter const *)arg1)->get_x_kernel_flags();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_get_y_kernel_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSepFilter *arg1 = (CvSepFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_get_y_kernel_flags",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvSepFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_get_y_kernel_flags" "', argument " "1"" of type '" "CvSepFilter const *""'");
}
arg1 = reinterpret_cast< CvSepFilter * >(argp1);
{
try {
result = (int)((CvSepFilter const *)arg1)->get_y_kernel_flags();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_gaussian_kernel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSepFilter_init_gaussian_kernel",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_gaussian_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSepFilter_init_gaussian_kernel" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
{
try {
CvSepFilter::init_gaussian_kernel(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_gaussian_kernel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSepFilter_init_gaussian_kernel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_gaussian_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
{
try {
CvSepFilter::init_gaussian_kernel(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_gaussian_kernel(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[3];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 1) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvSepFilter_init_gaussian_kernel__SWIG_1(self, args);
}
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_double(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_gaussian_kernel__SWIG_0(self, args);
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvSepFilter_init_gaussian_kernel'.\n"
" Possible C/C++ prototypes are:\n"
" init_gaussian_kernel(CvMat *,double)\n"
" CvSepFilter::init_gaussian_kernel(CvMat *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_sobel_kernel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
int arg5 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvSepFilter_init_sobel_kernel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
CvSepFilter::init_sobel_kernel(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_sobel_kernel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvSepFilter_init_sobel_kernel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_sobel_kernel" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
CvSepFilter::init_sobel_kernel(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_sobel_kernel(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[6];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 5); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_sobel_kernel__SWIG_1(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_sobel_kernel__SWIG_0(self, args);
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvSepFilter_init_sobel_kernel'.\n"
" Possible C/C++ prototypes are:\n"
" init_sobel_kernel(CvMat *,CvMat *,int,int,int)\n"
" CvSepFilter::init_sobel_kernel(CvMat *,CvMat *,int,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_scharr_kernel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
int arg5 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvSepFilter_init_scharr_kernel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
CvSepFilter::init_scharr_kernel(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_scharr_kernel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
int arg3 ;
int arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvSepFilter_init_scharr_kernel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvSepFilter_init_scharr_kernel" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
{
try {
CvSepFilter::init_scharr_kernel(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSepFilter_init_scharr_kernel(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[6];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 5); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_scharr_kernel__SWIG_1(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvSepFilter_init_scharr_kernel__SWIG_0(self, args);
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvSepFilter_init_scharr_kernel'.\n"
" Possible C/C++ prototypes are:\n"
" init_scharr_kernel(CvMat *,CvMat *,int,int,int)\n"
" CvSepFilter::init_scharr_kernel(CvMat *,CvMat *,int,int)\n");
return NULL;
}
SWIGINTERN PyObject *CvSepFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvSepFilter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvLinearFilter")) SWIG_fail;
{
try {
result = (CvLinearFilter *)new CvLinearFilter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvPoint arg5 ;
int arg6 ;
CvScalar arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvLinearFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvLinearFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLinearFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLinearFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLinearFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvLinearFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
arg5 = PyObject_to_CvPoint(obj4);
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvLinearFilter" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
arg7 = PyObject_to_CvScalar( obj6 );
}
{
try {
result = (CvLinearFilter *)new CvLinearFilter(arg1,arg2,arg3,(CvMat const *)arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvPoint arg5 ;
int arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvLinearFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvLinearFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLinearFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLinearFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLinearFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvLinearFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
arg5 = PyObject_to_CvPoint(obj4);
}
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvLinearFilter" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
result = (CvLinearFilter *)new CvLinearFilter(arg1,arg2,arg3,(CvMat const *)arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
CvPoint arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvLinearFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvLinearFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLinearFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLinearFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLinearFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvLinearFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
arg5 = PyObject_to_CvPoint(obj4);
}
{
try {
result = (CvLinearFilter *)new CvLinearFilter(arg1,arg2,arg3,(CvMat const *)arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
CvMat *arg4 = (CvMat *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvLinearFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvLinearFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLinearFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLinearFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLinearFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvLinearFilter" "', argument " "4"" of type '" "CvMat const *""'");
}
arg4 = reinterpret_cast< CvMat * >(argp4);
{
try {
result = (CvLinearFilter *)new CvLinearFilter(arg1,arg2,arg3,(CvMat const *)arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLinearFilter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[8];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 7); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvLinearFilter__SWIG_0(self, args);
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvLinearFilter__SWIG_4(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvLinearFilter__SWIG_3(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvLinearFilter__SWIG_2(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[6] );
}
if (_v) {
return _wrap_new_CvLinearFilter__SWIG_1(self, args);
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvLinearFilter'.\n"
" Possible C/C++ prototypes are:\n"
" CvLinearFilter()\n"
" CvLinearFilter(int,int,int,CvMat const *,CvPoint,int,CvScalar)\n"
" CvLinearFilter(int,int,int,CvMat const *,CvPoint,int)\n"
" CvLinearFilter(int,int,int,CvMat const *,CvPoint)\n"
" CvLinearFilter(int,int,int,CvMat const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvLinearFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvLinearFilter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvLinearFilter" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
int arg7 ;
CvScalar arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvLinearFilter_init" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
arg8 = PyObject_to_CvScalar( obj7 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
int arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvLinearFilter_init" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvPoint arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
arg6 = PyObject_to_CvPoint(obj5);
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLinearFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLinearFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvLinearFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_init" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLinearFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLinearFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLinearFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLinearFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLinearFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 5) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_3(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_2(self, args);
}
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_7(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_6(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[7] );
}
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_5(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLinearFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvLinearFilter_init__SWIG_4(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvLinearFilter_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvLinearFilter *,int,int,int,CvMat const *,CvPoint,int,CvScalar)\n"
" init(CvLinearFilter *,int,int,int,CvMat const *,CvPoint,int)\n"
" init(CvLinearFilter *,int,int,int,CvMat const *,CvPoint)\n"
" init(CvLinearFilter *,int,int,int,CvMat const *)\n"
" init(CvLinearFilter *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvLinearFilter *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvLinearFilter *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvLinearFilter *,int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLinearFilter_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_clear" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_get_kernel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLinearFilter_get_kernel",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_get_kernel" "', argument " "1"" of type '" "CvLinearFilter const *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
{
try {
result = (CvMat *)((CvLinearFilter const *)arg1)->get_kernel();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_get_kernel_sparse_buf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLinearFilter_get_kernel_sparse_buf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_get_kernel_sparse_buf" "', argument " "1"" of type '" "CvLinearFilter *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
{
try {
result = (uchar *)(arg1)->get_kernel_sparse_buf();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLinearFilter_get_kernel_sparse_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLinearFilter *arg1 = (CvLinearFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLinearFilter_get_kernel_sparse_count",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLinearFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLinearFilter_get_kernel_sparse_count" "', argument " "1"" of type '" "CvLinearFilter const *""'");
}
arg1 = reinterpret_cast< CvLinearFilter * >(argp1);
{
try {
result = (int)((CvLinearFilter const *)arg1)->get_kernel_sparse_count();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvLinearFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvLinearFilter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvBoxFilter")) SWIG_fail;
{
try {
result = (CvBoxFilter *)new CvBoxFilter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int arg7 ;
CvScalar arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
CvBoxFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_CvBoxFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBoxFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoxFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBoxFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBoxFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvBoxFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
arg8 = PyObject_to_CvScalar( obj7 );
}
{
try {
result = (CvBoxFilter *)new CvBoxFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvBoxFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvBoxFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBoxFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoxFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBoxFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBoxFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvBoxFilter" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
result = (CvBoxFilter *)new CvBoxFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
CvPoint arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvBoxFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvBoxFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBoxFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoxFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBoxFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBoxFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
arg6 = PyObject_to_CvPoint(obj5);
}
{
try {
result = (CvBoxFilter *)new CvBoxFilter(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
CvSize arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
void *argp5 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvBoxFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvBoxFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBoxFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoxFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBoxFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBoxFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBoxFilter" "', argument " "5"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp5);
arg5 = *temp;
if (SWIG_IsNewObj(res5)) delete temp;
}
}
{
try {
result = (CvBoxFilter *)new CvBoxFilter(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvBoxFilter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[9];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 8); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvBoxFilter__SWIG_0(self, args);
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvBoxFilter__SWIG_4(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvBoxFilter__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvBoxFilter__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[7] );
}
if (_v) {
return _wrap_new_CvBoxFilter__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvBoxFilter'.\n"
" Possible C/C++ prototypes are:\n"
" CvBoxFilter()\n"
" CvBoxFilter(int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" CvBoxFilter(int,int,int,bool,CvSize,CvPoint,int)\n"
" CvBoxFilter(int,int,int,bool,CvSize,CvPoint)\n"
" CvBoxFilter(int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvBoxFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_init" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoxFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoxFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBoxFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBoxFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvBoxFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvBoxFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_init" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoxFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoxFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBoxFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBoxFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvBoxFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvBoxFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_init" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoxFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoxFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBoxFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBoxFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvBoxFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_init" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoxFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoxFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBoxFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvBoxFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoxFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoxFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBoxFilter_init__SWIG_3(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoxFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvBoxFilter_init__SWIG_2(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoxFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvBoxFilter_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoxFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvBoxFilter_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvBoxFilter_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvBoxFilter *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvBoxFilter *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvBoxFilter *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvBoxFilter *,int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvBoxFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvBoxFilter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBoxFilter" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_is_normalized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBoxFilter_is_normalized",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_is_normalized" "', argument " "1"" of type '" "CvBoxFilter const *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
{
try {
result = (bool)((CvBoxFilter const *)arg1)->is_normalized();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_get_scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvBoxFilter_get_scale",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_get_scale" "', argument " "1"" of type '" "CvBoxFilter const *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
{
try {
result = (double)((CvBoxFilter const *)arg1)->get_scale();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_get_sum_buf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvBoxFilter_get_sum_buf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_get_sum_buf" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
{
try {
result = (uchar *)(arg1)->get_sum_buf();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvBoxFilter_get_sum_count_ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvBoxFilter *arg1 = (CvBoxFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvBoxFilter_get_sum_count_ptr",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvBoxFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoxFilter_get_sum_count_ptr" "', argument " "1"" of type '" "CvBoxFilter *""'");
}
arg1 = reinterpret_cast< CvBoxFilter * >(argp1);
{
try {
result = (int *)(arg1)->get_sum_count_ptr();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvBoxFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvBoxFilter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvLaplaceFilter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvLaplaceFilter")) SWIG_fail;
{
try {
result = (CvLaplaceFilter *)new CvLaplaceFilter();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLaplaceFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLaplaceFilter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
int arg5 ;
int arg6 ;
CvScalar arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvLaplaceFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvLaplaceFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLaplaceFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLaplaceFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLaplaceFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvLaplaceFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvLaplaceFilter" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvLaplaceFilter" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
arg7 = PyObject_to_CvScalar( obj6 );
}
{
try {
result = (CvLaplaceFilter *)new CvLaplaceFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLaplaceFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLaplaceFilter__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
int arg5 ;
int arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvLaplaceFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvLaplaceFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLaplaceFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLaplaceFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLaplaceFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvLaplaceFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvLaplaceFilter" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvLaplaceFilter" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
result = (CvLaplaceFilter *)new CvLaplaceFilter(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLaplaceFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLaplaceFilter__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
bool arg4 ;
int arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvLaplaceFilter *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvLaplaceFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLaplaceFilter" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLaplaceFilter" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvLaplaceFilter" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvLaplaceFilter" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvLaplaceFilter" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
{
try {
result = (CvLaplaceFilter *)new CvLaplaceFilter(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLaplaceFilter, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLaplaceFilter(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[8];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 7); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvLaplaceFilter__SWIG_0(self, args);
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvLaplaceFilter__SWIG_3(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvLaplaceFilter__SWIG_2(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[6] );
}
if (_v) {
return _wrap_new_CvLaplaceFilter__SWIG_1(self, args);
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvLaplaceFilter'.\n"
" Possible C/C++ prototypes are:\n"
" CvLaplaceFilter()\n"
" CvLaplaceFilter(int,int,int,bool,int,int,CvScalar)\n"
" CvLaplaceFilter(int,int,int,bool,int,int)\n"
" CvLaplaceFilter(int,int,int,bool,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvLaplaceFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvLaplaceFilter",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvLaplaceFilter" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
int arg6 ;
int arg7 ;
CvScalar arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvLaplaceFilter_init" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
arg8 = PyObject_to_CvScalar( obj7 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
int arg6 ;
int arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
int val7 ;
int ecode7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
ecode7 = SWIG_AsVal_int(obj6, &val7);
if (!SWIG_IsOK(ecode7)) {
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvLaplaceFilter_init" "', argument " "7"" of type '" "int""'");
}
arg7 = static_cast< int >(val7);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
int arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
int val6 ;
int ecode6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
ecode6 = SWIG_AsVal_int(obj5, &val6);
if (!SWIG_IsOK(ecode6)) {
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "int""'");
}
arg6 = static_cast< int >(val6);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLaplaceFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLaplaceFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLaplaceFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvLaplaceFilter_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvLaplaceFilter_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_init" "', argument " "1"" of type '" "CvLaplaceFilter *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLaplaceFilter_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLaplaceFilter_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvLaplaceFilter_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLaplaceFilter_init" "', argument " "5"" of type '" "CvMat const *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvLaplaceFilter_init" "', argument " "6"" of type '" "CvMat const *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
try {
(arg1)->init(arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_10(self, args);
}
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_6(self, args);
}
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_2(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_9(self, args);
}
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_5(self, args);
}
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_8(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_4(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[5], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[6], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[7] );
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_7(self, args);
}
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLaplaceFilter, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvLaplaceFilter_init__SWIG_3(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvLaplaceFilter_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvLaplaceFilter *,int,int,int,bool,int,int,CvScalar)\n"
" init(CvLaplaceFilter *,int,int,int,bool,int,int)\n"
" init(CvLaplaceFilter *,int,int,int,bool,int)\n"
" init(CvLaplaceFilter *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvLaplaceFilter *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvLaplaceFilter *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvLaplaceFilter *,int,int,int,bool,CvSize)\n"
" init(CvLaplaceFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint,int,CvScalar)\n"
" init(CvLaplaceFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint,int)\n"
" init(CvLaplaceFilter *,int,int,int,CvMat const *,CvMat const *,CvPoint)\n"
" init(CvLaplaceFilter *,int,int,int,CvMat const *,CvMat const *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_is_normalized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLaplaceFilter_is_normalized",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_is_normalized" "', argument " "1"" of type '" "CvLaplaceFilter const *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
{
try {
result = (bool)((CvLaplaceFilter const *)arg1)->is_normalized();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLaplaceFilter_is_basic_laplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLaplaceFilter *arg1 = (CvLaplaceFilter *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLaplaceFilter_is_basic_laplacian",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLaplaceFilter, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLaplaceFilter_is_basic_laplacian" "', argument " "1"" of type '" "CvLaplaceFilter const *""'");
}
arg1 = reinterpret_cast< CvLaplaceFilter * >(argp1);
{
try {
result = (bool)((CvLaplaceFilter const *)arg1)->is_basic_laplacian();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvLaplaceFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvLaplaceFilter, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvMorphology")) SWIG_fail;
{
try {
result = (CvMorphology *)new CvMorphology();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_CvMorphology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMorphology" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMorphology" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMorphology" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvMorphology" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMorphology" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvMorphology" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
result = (CvMorphology *)new CvMorphology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_CvMorphology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMorphology" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMorphology" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMorphology" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvMorphology" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMorphology" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvMorphology" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
result = (CvMorphology *)new CvMorphology(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvSize arg6 ;
CvPoint arg7 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CvMorphology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMorphology" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMorphology" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMorphology" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvMorphology" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMorphology" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
result = (CvMorphology *)new CvMorphology(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
CvSize arg6 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CvMorphology",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMorphology" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMorphology" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMorphology" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvMorphology" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMorphology" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMorphology" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
result = (CvMorphology *)new CvMorphology(arg1,arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
CvMat *arg5 = (CvMat *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
CvMorphology *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CvMorphology",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvMorphology" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvMorphology" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMorphology" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvMorphology" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMorphology" "', argument " "5"" of type '" "CvMat *""'");
}
arg5 = reinterpret_cast< CvMat * >(argp5);
{
try {
result = (CvMorphology *)new CvMorphology(arg1,arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMorphology, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvMorphology(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[10];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvMorphology__SWIG_0(self, args);
}
if (argc == 5) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMorphology__SWIG_5(self, args);
}
}
}
}
}
}
if (argc == 6) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMorphology__SWIG_4(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvMorphology__SWIG_3(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvMorphology__SWIG_2(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_new_CvMorphology__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvMorphology'.\n"
" Possible C/C++ prototypes are:\n"
" CvMorphology()\n"
" CvMorphology(int,int,int,int,CvMat *,CvSize,CvPoint,int,CvScalar)\n"
" CvMorphology(int,int,int,int,CvMat *,CvSize,CvPoint,int)\n"
" CvMorphology(int,int,int,int,CvMat *,CvSize,CvPoint)\n"
" CvMorphology(int,int,int,int,CvMat *,CvSize)\n"
" CvMorphology(int,int,int,int,CvMat *)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvMorphology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvMorphology",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMorphology" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
CvSize arg7 ;
CvPoint arg8 ;
int arg9 ;
CvScalar arg10 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
int val9 ;
int ecode9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
PyObject * obj9 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
{
arg8 = PyObject_to_CvPoint(obj7);
}
ecode9 = SWIG_AsVal_int(obj8, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CvMorphology_init" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
{
arg10 = PyObject_to_CvScalar( obj9 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
CvSize arg7 ;
CvPoint arg8 ;
int arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
int val9 ;
int ecode9 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
{
arg8 = PyObject_to_CvPoint(obj7);
}
ecode9 = SWIG_AsVal_int(obj8, &val9);
if (!SWIG_IsOK(ecode9)) {
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CvMorphology_init" "', argument " "9"" of type '" "int""'");
}
arg9 = static_cast< int >(val9);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
CvSize arg7 ;
CvPoint arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
{
arg8 = PyObject_to_CvPoint(obj7);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
CvSize arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
void *argp7 ;
int res7 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res7)) {
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
}
if (!argp7) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "7"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp7);
arg7 = *temp;
if (SWIG_IsNewObj(res7)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
int arg5 ;
CvMat *arg6 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
int val5 ;
int ecode5 = 0 ;
void *argp6 = 0 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvMat *""'");
}
arg6 = reinterpret_cast< CvMat * >(argp6);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
CvScalar arg9 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
PyObject * obj8 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvMorphology_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
arg9 = PyObject_to_CvScalar( obj8 );
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
int arg8 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
int val8 ;
int ecode8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
PyObject * obj7 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
ecode8 = SWIG_AsVal_int(obj7, &val8);
if (!SWIG_IsOK(ecode8)) {
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvMorphology_init" "', argument " "8"" of type '" "int""'");
}
arg8 = static_cast< int >(val8);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
CvPoint arg7 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
arg7 = PyObject_to_CvPoint(obj6);
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
int arg2 ;
int arg3 ;
int arg4 ;
bool arg5 ;
CvSize arg6 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
void *argp6 ;
int res6 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:CvMorphology_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMorphology_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMorphology_init" "', argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvMorphology_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_CvSize, 0 | 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
}
if (!argp6) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvMorphology_init" "', argument " "6"" of type '" "CvSize""'");
} else {
CvSize * temp = reinterpret_cast< CvSize * >(argp6);
arg6 = *temp;
if (SWIG_IsNewObj(res6)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4,arg5,arg6);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[11];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 10); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init__SWIG_4(self, args);
}
}
}
}
}
}
}
if (argc == 6) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init__SWIG_8(self, args);
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init__SWIG_3(self, args);
}
}
}
}
}
}
}
}
if (argc == 7) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init__SWIG_7(self, args);
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init__SWIG_2(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 8) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMorphology_init__SWIG_6(self, args);
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[8], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMorphology_init__SWIG_1(self, args);
}
}
}
}
}
}
}
}
}
}
if (argc == 9) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[7], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[8] );
}
if (_v) {
return _wrap_CvMorphology_init__SWIG_5(self, args);
}
}
}
}
}
}
}
}
}
}
if (argc == 10) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMorphology, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_CvSize, 0);
_v = SWIG_CheckState(res);
if (_v) {
int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[8], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
_v = CvScalar_Check( argv[9] );
}
if (_v) {
return _wrap_CvMorphology_init__SWIG_0(self, args);
}
}
}
}
}
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMorphology_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvMorphology *,int,int,int,int,CvMat *,CvSize,CvPoint,int,CvScalar)\n"
" init(CvMorphology *,int,int,int,int,CvMat *,CvSize,CvPoint,int)\n"
" init(CvMorphology *,int,int,int,int,CvMat *,CvSize,CvPoint)\n"
" init(CvMorphology *,int,int,int,int,CvMat *,CvSize)\n"
" init(CvMorphology *,int,int,int,int,CvMat *)\n"
" init(CvMorphology *,int,int,int,bool,CvSize,CvPoint,int,CvScalar)\n"
" init(CvMorphology *,int,int,int,bool,CvSize,CvPoint,int)\n"
" init(CvMorphology *,int,int,int,bool,CvSize,CvPoint)\n"
" init(CvMorphology *,int,int,int,bool,CvSize)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_clear" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_get_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_get_element",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_get_element" "', argument " "1"" of type '" "CvMorphology const *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
result = (CvMat *)((CvMorphology const *)arg1)->get_element();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_get_element_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_get_element_shape",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_get_element_shape" "', argument " "1"" of type '" "CvMorphology const *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
result = (int)((CvMorphology const *)arg1)->get_element_shape();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_get_operation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_get_operation",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_get_operation" "', argument " "1"" of type '" "CvMorphology const *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
result = (int)((CvMorphology const *)arg1)->get_operation();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_get_element_sparse_buf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
uchar *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_get_element_sparse_buf",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_get_element_sparse_buf" "', argument " "1"" of type '" "CvMorphology *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
result = (uchar *)(arg1)->get_element_sparse_buf();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_get_element_sparse_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMorphology *arg1 = (CvMorphology *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvMorphology_get_element_sparse_count",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMorphology, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_get_element_sparse_count" "', argument " "1"" of type '" "CvMorphology const *""'");
}
arg1 = reinterpret_cast< CvMorphology * >(argp1);
{
try {
result = (int)((CvMorphology const *)arg1)->get_element_sparse_count();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init_binary_element__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
CvPoint arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvMorphology_init_binary_element",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init_binary_element" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init_binary_element" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
arg3 = PyObject_to_CvPoint(obj2);
}
{
try {
CvMorphology::init_binary_element(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init_binary_element__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvMat *arg1 = (CvMat *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvMorphology_init_binary_element",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMorphology_init_binary_element" "', argument " "1"" of type '" "CvMat *""'");
}
arg1 = reinterpret_cast< CvMat * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMorphology_init_binary_element" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
CvMorphology::init_binary_element(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvMorphology_init_binary_element(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[4];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 2) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvMorphology_init_binary_element__SWIG_1(self, args);
}
}
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvPoint, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvMorphology_init_binary_element__SWIG_0(self, args);
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvMorphology_init_binary_element'.\n"
" Possible C/C++ prototypes are:\n"
" init_binary_element(CvMat *,int,CvPoint)\n"
" CvMorphology::init_binary_element(CvMat *,int)\n");
return NULL;
}
SWIGINTERN PyObject *CvMorphology_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvMorphology, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_new_CvLevMarq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvLevMarq")) SWIG_fail;
{
try {
result = (CvLevMarq *)new CvLevMarq();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLevMarq, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLevMarq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
CvTermCriteria arg3 ;
bool arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 ;
int res3 = 0 ;
bool val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
CvLevMarq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CvLevMarq",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLevMarq" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLevMarq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvLevMarq" "', argument " "3"" of type '" "CvTermCriteria""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvLevMarq" "', argument " "3"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
ecode4 = SWIG_AsVal_bool(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvLevMarq" "', argument " "4"" of type '" "bool""'");
}
arg4 = static_cast< bool >(val4);
{
try {
result = (CvLevMarq *)new CvLevMarq(arg1,arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLevMarq, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLevMarq__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
CvTermCriteria arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
CvLevMarq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:new_CvLevMarq",&obj0,&obj1,&obj2)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLevMarq" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLevMarq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvLevMarq" "', argument " "3"" of type '" "CvTermCriteria""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvLevMarq" "', argument " "3"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp3);
arg3 = *temp;
if (SWIG_IsNewObj(res3)) delete temp;
}
}
{
try {
result = (CvLevMarq *)new CvLevMarq(arg1,arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLevMarq, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLevMarq__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvLevMarq *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:new_CvLevMarq",&obj0,&obj1)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvLevMarq" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvLevMarq" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvLevMarq *)new CvLevMarq(arg1,arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLevMarq, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvLevMarq(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[5];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 0) {
return _wrap_new_CvLevMarq__SWIG_0(self, args);
}
if (argc == 2) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvLevMarq__SWIG_3(self, args);
}
}
}
if (argc == 3) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_new_CvLevMarq__SWIG_2(self, args);
}
}
}
}
if (argc == 4) {
int _v;
{
int res = SWIG_AsVal_int(argv[0], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[3], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_new_CvLevMarq__SWIG_1(self, args);
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CvLevMarq'.\n"
" Possible C/C++ prototypes are:\n"
" CvLevMarq()\n"
" CvLevMarq(int,int,CvTermCriteria,bool)\n"
" CvLevMarq(int,int,CvTermCriteria)\n"
" CvLevMarq(int,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvLevMarq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvLevMarq",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvLevMarq" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
int arg3 ;
CvTermCriteria arg4 ;
bool arg5 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 ;
int res4 = 0 ;
bool val5 ;
int ecode5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvLevMarq_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_init" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLevMarq_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvLevMarq_init" "', argument " "4"" of type '" "CvTermCriteria""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_init" "', argument " "4"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
ecode5 = SWIG_AsVal_bool(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvLevMarq_init" "', argument " "5"" of type '" "bool""'");
}
arg5 = static_cast< bool >(val5);
{
try {
(arg1)->init(arg2,arg3,arg4,arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
int arg3 ;
CvTermCriteria arg4 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
void *argp4 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvLevMarq_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_init" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLevMarq_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_CvTermCriteria, 0 | 0);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvLevMarq_init" "', argument " "4"" of type '" "CvTermCriteria""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_init" "', argument " "4"" of type '" "CvTermCriteria""'");
} else {
CvTermCriteria * temp = reinterpret_cast< CvTermCriteria * >(argp4);
arg4 = *temp;
if (SWIG_IsNewObj(res4)) delete temp;
}
}
{
try {
(arg1)->init(arg2,arg3,arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvLevMarq_init",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_init" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_init" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvLevMarq_init" "', argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
try {
(arg1)->init(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_init(PyObject *self, PyObject *args) {
int argc;
PyObject *argv[6];
int ii;
if (!PyTuple_Check(args)) SWIG_fail;
argc = (int)PyObject_Length(args);
for (ii = 0; (ii < argc) && (ii < 5); ii++) {
argv[ii] = PyTuple_GET_ITEM(args,ii);
}
if (argc == 3) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLevMarq, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLevMarq_init__SWIG_2(self, args);
}
}
}
}
if (argc == 4) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLevMarq, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
return _wrap_CvLevMarq_init__SWIG_1(self, args);
}
}
}
}
}
if (argc == 5) {
int _v;
void *vptr = 0;
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvLevMarq, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_int(argv[1], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
{
int res = SWIG_AsVal_int(argv[2], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_CvTermCriteria, 0);
_v = SWIG_CheckState(res);
if (_v) {
{
int res = SWIG_AsVal_bool(argv[4], NULL);
_v = SWIG_CheckState(res);
}
if (_v) {
return _wrap_CvLevMarq_init__SWIG_0(self, args);
}
}
}
}
}
}
fail:
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CvLevMarq_init'.\n"
" Possible C/C++ prototypes are:\n"
" init(CvLevMarq *,int,int,CvTermCriteria,bool)\n"
" init(CvLevMarq *,int,int,CvTermCriteria)\n"
" init(CvLevMarq *,int,int)\n");
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat **arg2 = 0 ;
CvMat **arg3 = 0 ;
CvMat **arg4 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOO:CvLevMarq_update",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_update" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_update" "', argument " "2"" of type '" "CvMat const *&""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_update" "', argument " "2"" of type '" "CvMat const *&""'");
}
arg2 = reinterpret_cast< CvMat ** >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvLevMarq_update" "', argument " "3"" of type '" "CvMat *&""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_update" "', argument " "3"" of type '" "CvMat *&""'");
}
arg3 = reinterpret_cast< CvMat ** >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvLevMarq_update" "', argument " "4"" of type '" "CvMat *&""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_update" "', argument " "4"" of type '" "CvMat *&""'");
}
arg4 = reinterpret_cast< CvMat ** >(argp4);
{
try {
result = (bool)(arg1)->update((CvMat const *&)*arg2,*arg3,*arg4);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_updateAlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat **arg2 = 0 ;
CvMat **arg3 = 0 ;
CvMat **arg4 = 0 ;
double **arg5 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res5 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"OOOOO:CvLevMarq_updateAlt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_updateAlt" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_updateAlt" "', argument " "2"" of type '" "CvMat const *&""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_updateAlt" "', argument " "2"" of type '" "CvMat const *&""'");
}
arg2 = reinterpret_cast< CvMat ** >(argp2);
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvLevMarq_updateAlt" "', argument " "3"" of type '" "CvMat *&""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_updateAlt" "', argument " "3"" of type '" "CvMat *&""'");
}
arg3 = reinterpret_cast< CvMat ** >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_CvMat, 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvLevMarq_updateAlt" "', argument " "4"" of type '" "CvMat *&""'");
}
if (!argp4) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_updateAlt" "', argument " "4"" of type '" "CvMat *&""'");
}
arg4 = reinterpret_cast< CvMat ** >(argp4);
res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_p_double, 0 );
if (!SWIG_IsOK(res5)) {
SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvLevMarq_updateAlt" "', argument " "5"" of type '" "double *&""'");
}
if (!argp5) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvLevMarq_updateAlt" "', argument " "5"" of type '" "double *&""'");
}
arg5 = reinterpret_cast< double ** >(argp5);
{
try {
result = (bool)(arg1)->updateAlt((CvMat const *&)*arg2,*arg3,*arg4,*arg5);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_clear",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_clear" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
{
try {
(arg1)->clear();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_step",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_step" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
{
try {
(arg1)->step();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_mask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_mask_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_mask_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_mask_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->mask = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_mask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_mask_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_mask_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->mask);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_prevParam_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_prevParam_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_prevParam_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_prevParam_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->prevParam = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_prevParam_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_prevParam_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_prevParam_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->prevParam);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_param_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_param_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_param_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_param_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->param = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_param_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_param_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_param_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->param);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_J_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_J_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_J_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->J = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_J_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_J_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->J);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_err_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_err_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_err_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->err = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_err_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_err_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->err);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_JtJ_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJ_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_JtJ_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->JtJ = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_JtJ_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJ_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->JtJ);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJN_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_JtJN_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJN_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_JtJN_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->JtJN = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJN_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_JtJN_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJN_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->JtJN);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtErr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_JtErr_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtErr_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_JtErr_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->JtErr = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtErr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_JtErr_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtErr_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->JtErr);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_JtJV_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJV_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_JtJV_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->JtJV = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_JtJV_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJV_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->JtJV);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvMat *arg2 = (CvMat *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_JtJW_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJW_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_JtJW_set" "', argument " "2"" of type '" "CvMat *""'");
}
arg2 = reinterpret_cast< CvMat * >(argp2);
if (arg1) (arg1)->JtJW = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_JtJW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvMat *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_JtJW_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_JtJW_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvMat *) ((arg1)->JtJW);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_prevErrNorm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_prevErrNorm_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_prevErrNorm_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_prevErrNorm_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->prevErrNorm = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_prevErrNorm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_prevErrNorm_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_prevErrNorm_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (double) ((arg1)->prevErrNorm);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_errNorm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
double arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_errNorm_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_errNorm_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_double(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_errNorm_set" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
if (arg1) (arg1)->errNorm = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_errNorm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
double result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_errNorm_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_errNorm_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (double) ((arg1)->errNorm);
resultobj = SWIG_From_double(static_cast< double >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_lambdaLg10_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_lambdaLg10_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_lambdaLg10_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_lambdaLg10_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->lambdaLg10 = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_lambdaLg10_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_lambdaLg10_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_lambdaLg10_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (int) ((arg1)->lambdaLg10);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_criteria_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
CvTermCriteria *arg2 = (CvTermCriteria *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_criteria_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_criteria_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLevMarq_criteria_set" "', argument " "2"" of type '" "CvTermCriteria *""'");
}
arg2 = reinterpret_cast< CvTermCriteria * >(argp2);
if (arg1) (arg1)->criteria = *arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_criteria_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTermCriteria *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_criteria_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_criteria_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (CvTermCriteria *)& ((arg1)->criteria);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_state_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_state_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_state_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->state = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_state_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_state_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (int) ((arg1)->state);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_iters_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_iters_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_iters_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_iters_set" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
if (arg1) (arg1)->iters = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_iters_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_iters_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_iters_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (int) ((arg1)->iters);
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_completeSymmFlag_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
bool arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvLevMarq_completeSymmFlag_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_completeSymmFlag_set" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLevMarq_completeSymmFlag_set" "', argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
if (arg1) (arg1)->completeSymmFlag = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvLevMarq_completeSymmFlag_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvLevMarq *arg1 = (CvLevMarq *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
bool result;
if (!PyArg_ParseTuple(args,(char *)"O:CvLevMarq_completeSymmFlag_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvLevMarq, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLevMarq_completeSymmFlag_get" "', argument " "1"" of type '" "CvLevMarq *""'");
}
arg1 = reinterpret_cast< CvLevMarq * >(argp1);
result = (bool) ((arg1)->completeSymmFlag);
resultobj = SWIG_From_bool(static_cast< bool >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvLevMarq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvLevMarq, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvTuple_CvPoint_2_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ;
CvPoint *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_CvPoint_2_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2_val_set" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_CvPoint_2_val_set" "', argument " "2"" of type '" "CvPoint [2]""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""CvPoint [2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_CvPoint_2_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTuple_CvPoint_2_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2_val_get" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp1);
result = (CvPoint *)(CvPoint *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_CvPoint_2___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ;
int arg2 ;
CvPoint *arg3 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvTuple_CvPoint_2___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___setitem__" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvTuple_CvPoint_2___setitem__" "', argument " "3"" of type '" "CvPoint *""'");
}
arg3 = reinterpret_cast< CvPoint * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_CvPoint_2___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_CvPoint_2___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___getitem__" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
{
CvPoint const &_result_ref = (arg1)->__getitem__(arg2);
result = (CvPoint *) &_result_ref;
}
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTuple_CvPoint_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTuple_CvPoint_2")) SWIG_fail;
{
try {
result = (CvTuple< CvPoint,2 > *)new CvTuple< CvPoint,2 >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTuple_CvPoint_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTuple_CvPoint_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_CvPoint_2" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTuple_CvPoint_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTupleT_CvPoint_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvTuple_float_2_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 0 ;
float *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_float_2_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2_val_set" "', argument " "1"" of type '" "CvTuple< float,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,2 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_float_2_val_set" "', argument " "2"" of type '" "float [2]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_2_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTuple_float_2_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2_val_get" "', argument " "1"" of type '" "CvTuple< float,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,2 > * >(argp1);
result = (float *)(float *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_2___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 0 ;
int arg2 ;
float *arg3 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvTuple_float_2___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___setitem__" "', argument " "1"" of type '" "CvTuple< float,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvTuple_float_2___setitem__" "', argument " "3"" of type '" "float *""'");
}
arg3 = reinterpret_cast< float * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_2___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_float_2___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___getitem__" "', argument " "1"" of type '" "CvTuple< float,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,2 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
{
float const &_result_ref = (arg1)->__getitem__(arg2);
result = (float *) &_result_ref;
}
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTuple_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTuple_float_2")) SWIG_fail;
{
try {
result = (CvTuple< float,2 > *)new CvTuple< float,2 >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTuple_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTuple_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_2_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_float_2" "', argument " "1"" of type '" "CvTuple< float,2 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,2 > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTuple_float_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTupleT_float_2_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvTuple_float_3_val_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 0 ;
float *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_float_3_val_set",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3_val_set" "', argument " "1"" of type '" "CvTuple< float,3 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,3 > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_float_3_val_set" "', argument " "2"" of type '" "float [2]""'");
}
arg2 = reinterpret_cast< float * >(argp2);
{
if (arg2) {
size_t ii = 0;
for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii];
} else {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""float [2]""'");
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_3_val_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvTuple_float_3_val_get",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3_val_get" "', argument " "1"" of type '" "CvTuple< float,3 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,3 > * >(argp1);
result = (float *)(float *) ((arg1)->val);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_3___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 0 ;
int arg2 ;
float *arg3 = (float *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvTuple_float_3___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___setitem__" "', argument " "1"" of type '" "CvTuple< float,3 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvTuple_float_3___setitem__" "', argument " "3"" of type '" "float *""'");
}
arg3 = reinterpret_cast< float * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvTuple_float_3___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
float *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvTuple_float_3___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___getitem__" "', argument " "1"" of type '" "CvTuple< float,3 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,3 > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
{
float const &_result_ref = (arg1)->__getitem__(arg2);
result = (float *) &_result_ref;
}
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_float(static_cast< float >(*result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvTuple_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvTuple_float_3")) SWIG_fail;
{
try {
result = (CvTuple< float,3 > *)new CvTuple< float,3 >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvTuple_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvTuple_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTupleT_float_3_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_float_3" "', argument " "1"" of type '" "CvTuple< float,3 > *""'");
}
arg1 = reinterpret_cast< CvTuple< float,3 > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvTuple_float_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTupleT_float_3_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvPoint > *)CvTypedSeq< CvPoint >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvPoint *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ;
int arg2 ;
CvPoint *arg3 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvPoint___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint___setitem__" "', argument " "3"" of type '" "CvPoint *""'");
}
arg3 = reinterpret_cast< CvPoint * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ;
CvPoint *arg2 = (CvPoint *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_append" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint_append" "', argument " "2"" of type '" "CvPoint *""'");
}
arg2 = reinterpret_cast< CvPoint * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_pop" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint > * >(argp1);
{
try {
result = (CvPoint *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvPoint")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvPoint > *)new CvTypedSeq< CvPoint >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvPoint",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvPoint_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint2D32f_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvPoint2D32f > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint2D32f_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvPoint2D32f > *)CvTypedSeq< CvPoint2D32f >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint2D32f___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint2D32f___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint2D32f > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvPoint2D32f *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint2D32f___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ;
int arg2 ;
CvPoint2D32f *arg3 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvPoint2D32f___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint2D32f > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint2D32f___setitem__" "', argument " "3"" of type '" "CvPoint2D32f *""'");
}
arg3 = reinterpret_cast< CvPoint2D32f * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint2D32f_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ;
CvPoint2D32f *arg2 = (CvPoint2D32f *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint2D32f_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f_append" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint2D32f > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint2D32f_append" "', argument " "2"" of type '" "CvPoint2D32f *""'");
}
arg2 = reinterpret_cast< CvPoint2D32f * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint2D32f_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvPoint2D32f *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint2D32f_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f_pop" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint2D32f > * >(argp1);
{
try {
result = (CvPoint2D32f *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvPoint2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvPoint2D32f")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvPoint2D32f > *)new CvTypedSeq< CvPoint2D32f >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvPoint2D32f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvPoint2D32f",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint2D32f" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvPoint2D32f > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvPoint2D32f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvRect_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvRect_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvRect > *)CvTypedSeq< CvRect >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvRect___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvRect___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvRect > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvRect *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvRect___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ;
int arg2 ;
CvRect *arg3 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvRect___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvRect > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvRect___setitem__" "', argument " "3"" of type '" "CvRect *""'");
}
arg3 = reinterpret_cast< CvRect * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvRect_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ;
CvRect *arg2 = (CvRect *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvRect_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect_append" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvRect > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvRect, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvRect_append" "', argument " "2"" of type '" "CvRect *""'");
}
arg2 = reinterpret_cast< CvRect * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvRect_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvRect *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvRect_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect_pop" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvRect > * >(argp1);
{
try {
result = (CvRect *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvRect")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvRect > *)new CvTypedSeq< CvRect >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvRect",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvRect" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvRect > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvRect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvRect_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvSeq_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvSeq * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvSeq_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvSeq * > *)CvTypedSeq< CvSeq * >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvSeq___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvSeq **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvSeq___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvSeq * > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvSeq **)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvSeq___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ;
int arg2 ;
CvSeq **arg3 = (CvSeq **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *vptr3 ;
CvSeq *buffer3 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvSeq___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvSeq * > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
if ((SWIG_ConvertPtr(obj2, &vptr3, SWIGTYPE_p_CvSeq, 1)) == -1){
SWIG_fail;
}
buffer3 = (CvSeq *) vptr3;
arg3=&buffer3;
}
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvSeq_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ;
CvSeq **arg2 = (CvSeq **) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *vptr2 ;
CvSeq *buffer2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvSeq_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq_append" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvSeq * > * >(argp1);
{
if ((SWIG_ConvertPtr(obj1, &vptr2, SWIGTYPE_p_CvSeq, 1)) == -1){
SWIG_fail;
}
buffer2 = (CvSeq *) vptr2;
arg2=&buffer2;
}
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvSeq_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvSeq **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvSeq_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq_pop" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvSeq * > * >(argp1);
{
try {
result = (CvSeq **)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSeq, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvSeq")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvSeq * > *)new CvTypedSeq< CvSeq * >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvSeq",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvSeq" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvSeq * > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvSeq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvQuadEdge2D_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvQuadEdge2D > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvQuadEdge2D_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvQuadEdge2D > *)CvTypedSeq< CvQuadEdge2D >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvQuadEdge2D___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvQuadEdge2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvQuadEdge2D___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvQuadEdge2D *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvQuadEdge2D___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
int arg2 ;
CvQuadEdge2D *arg3 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvQuadEdge2D___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvQuadEdge2D___setitem__" "', argument " "3"" of type '" "CvQuadEdge2D *""'");
}
arg3 = reinterpret_cast< CvQuadEdge2D * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvQuadEdge2D_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
CvQuadEdge2D *arg2 = (CvQuadEdge2D *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvQuadEdge2D_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D_append" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvQuadEdge2D_append" "', argument " "2"" of type '" "CvQuadEdge2D *""'");
}
arg2 = reinterpret_cast< CvQuadEdge2D * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvQuadEdge2D_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvQuadEdge2D *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvQuadEdge2D_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D_pop" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp1);
{
try {
result = (CvQuadEdge2D *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvQuadEdge2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvQuadEdge2D")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvQuadEdge2D > *)new CvTypedSeq< CvQuadEdge2D >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvQuadEdge2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvQuadEdge2D",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvQuadEdge2D" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvQuadEdge2D > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvQuadEdge2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvConnectedComp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvConnectedComp > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvConnectedComp_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvConnectedComp > *)CvTypedSeq< CvConnectedComp >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvConnectedComp___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvConnectedComp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvConnectedComp___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvConnectedComp > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvConnectedComp *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvConnectedComp___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ;
int arg2 ;
CvConnectedComp *arg3 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvConnectedComp___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvConnectedComp > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvConnectedComp___setitem__" "', argument " "3"" of type '" "CvConnectedComp *""'");
}
arg3 = reinterpret_cast< CvConnectedComp * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvConnectedComp_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ;
CvConnectedComp *arg2 = (CvConnectedComp *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvConnectedComp_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp_append" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvConnectedComp > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvConnectedComp, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvConnectedComp_append" "', argument " "2"" of type '" "CvConnectedComp *""'");
}
arg2 = reinterpret_cast< CvConnectedComp * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvConnectedComp_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvConnectedComp *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvConnectedComp_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp_pop" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvConnectedComp > * >(argp1);
{
try {
result = (CvConnectedComp *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvConnectedComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvConnectedComp")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvConnectedComp > *)new CvTypedSeq< CvConnectedComp >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvConnectedComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvConnectedComp",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvConnectedComp" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvConnectedComp > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvConnectedComp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_2_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvTuple< CvPoint,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint_2_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvTuple< CvPoint,2 > > *)CvTypedSeq< CvTuple< CvPoint,2 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_2___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvTuple< CvPoint,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint_2___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< CvPoint,2 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvTuple< CvPoint,2 > *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_2___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ;
int arg2 ;
CvTuple< CvPoint,2 > *arg3 = (CvTuple< CvPoint,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_CvPoint_2___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< CvPoint,2 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint_2___setitem__" "', argument " "3"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg3 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_2_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ;
CvTuple< CvPoint,2 > *arg2 = (CvTuple< CvPoint,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_CvPoint_2_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< CvPoint,2 > > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint_2_append" "', argument " "2"" of type '" "CvTuple< CvPoint,2 > *""'");
}
arg2 = reinterpret_cast< CvTuple< CvPoint,2 > * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_CvPoint_2_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTuple< CvPoint,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_CvPoint_2_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< CvPoint,2 > > * >(argp1);
{
try {
result = (CvTuple< CvPoint,2 > *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_CvPoint_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_CvPoint_2")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvTuple< CvPoint,2 > > *)new CvTypedSeq< CvTuple< CvPoint,2 > >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_CvPoint_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_CvPoint_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint_2" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< CvPoint,2 > > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_CvPoint_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_float_2_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvTuple< float,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_float_2_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvTuple< float,2 > > *)CvTypedSeq< CvTuple< float,2 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_2___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvTuple< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_float_2___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,2 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvTuple< float,2 > *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_2___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ;
int arg2 ;
CvTuple< float,2 > *arg3 = (CvTuple< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_float_2___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,2 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_2___setitem__" "', argument " "3"" of type '" "CvTuple< float,2 > *""'");
}
arg3 = reinterpret_cast< CvTuple< float,2 > * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_2_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ;
CvTuple< float,2 > *arg2 = (CvTuple< float,2 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_float_2_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,2 > > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_float_2_append" "', argument " "2"" of type '" "CvTuple< float,2 > *""'");
}
arg2 = reinterpret_cast< CvTuple< float,2 > * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_2_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTuple< float,2 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_float_2_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,2 > > * >(argp1);
{
try {
result = (CvTuple< float,2 > *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_float_2")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvTuple< float,2 > > *)new CvTypedSeq< CvTuple< float,2 > >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_float_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_float_2",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_float_2" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,2 > > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_float_2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_CvSeq_float_3_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvSeq *arg1 = (CvSeq *) 0 ;
void *ptr1 ;
PyObject * obj0 = 0 ;
CvTypedSeq< CvTuple< float,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_float_3_cast",&obj0)) SWIG_fail;
{
if( SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSet, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvChain, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContour, 0) == -1 &&
SWIG_ConvertPtr(obj0, &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
return NULL;
}
arg1 = (CvSeq *) ptr1;
}
{
try {
result = (CvTypedSeq< CvTuple< float,3 > > *)CvTypedSeq< CvTuple< float,3 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_3___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
CvTuple< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_float_3___getitem__",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___getitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,3 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___getitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
try {
result = (CvTuple< float,3 > *)(arg1)->__getitem__(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_3___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ;
int arg2 ;
CvTuple< float,3 > *arg3 = (CvTuple< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OOO:CvSeq_float_3___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___setitem__" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,3 > > * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___setitem__" "', argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_3___setitem__" "', argument " "3"" of type '" "CvTuple< float,3 > *""'");
}
arg3 = reinterpret_cast< CvTuple< float,3 > * >(argp3);
{
try {
(arg1)->__setitem__(arg2,arg3);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_3_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ;
CvTuple< float,3 > *arg2 = (CvTuple< float,3 > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"OO:CvSeq_float_3_append",&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,3 > > * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_float_3_append" "', argument " "2"" of type '" "CvTuple< float,3 > *""'");
}
arg2 = reinterpret_cast< CvTuple< float,3 > * >(argp2);
{
try {
(arg1)->append(arg2);
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_CvSeq_float_3_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
CvTuple< float,3 > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:CvSeq_float_3_pop",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,3 > > * >(argp1);
{
try {
result = (CvTuple< float,3 > *)(arg1)->pop();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_new_CvSeq_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":new_CvSeq_float_3")) SWIG_fail;
{
try {
result = (CvTypedSeq< CvTuple< float,3 > > *)new CvTypedSeq< CvTuple< float,3 > >();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_delete_CvSeq_float_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
if (!PyArg_ParseTuple(args,(char *)"O:delete_CvSeq_float_3",&obj0)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_float_3" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'");
}
arg1 = reinterpret_cast< CvTypedSeq< CvTuple< float,3 > > * >(argp1);
{
try {
delete arg1;
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *CvSeq_float_3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
SWIG_TypeNewClientData(SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
SWIGINTERN PyObject *_wrap_SendErrorToPython(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
int arg5 ;
void *arg6 = (void *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int val5 ;
int ecode5 = 0 ;
int res6 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
int result;
if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SendErrorToPython",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SendErrorToPython" "', argument " "1"" of type '" "int""'");
}
arg1 = static_cast< int >(val1);
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SendErrorToPython" "', argument " "2"" of type '" "char const *""'");
}
arg2 = reinterpret_cast< char * >(buf2);
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SendErrorToPython" "', argument " "3"" of type '" "char const *""'");
}
arg3 = reinterpret_cast< char * >(buf3);
res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SendErrorToPython" "', argument " "4"" of type '" "char const *""'");
}
arg4 = reinterpret_cast< char * >(buf4);
ecode5 = SWIG_AsVal_int(obj4, &val5);
if (!SWIG_IsOK(ecode5)) {
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SendErrorToPython" "', argument " "5"" of type '" "int""'");
}
arg5 = static_cast< int >(val5);
res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6), 0, 0);
if (!SWIG_IsOK(res6)) {
SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SendErrorToPython" "', argument " "6"" of type '" "void *""'");
}
{
try {
try {
result = (int)SendErrorToPython(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
}
catch(int &_e) {
SWIG_Python_Raise(SWIG_From_int(static_cast< int >(_e)), "int", 0); SWIG_fail;
}
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_From_int(static_cast< int >(result));
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return resultobj;
fail:
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
return NULL;
}
SWIGINTERN PyObject *_wrap_function_ptr_generator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
CvErrorCallback result;
if (!PyArg_ParseTuple(args,(char *)":function_ptr_generator")) SWIG_fail;
{
try {
result = (CvErrorCallback)function_ptr_generator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int);
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_void_ptr_generator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void *result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":void_ptr_generator")) SWIG_fail;
{
try {
result = (void *)void_ptr_generator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_void_ptrptr_generator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
void **result = 0 ;
if (!PyArg_ParseTuple(args,(char *)":void_ptrptr_generator")) SWIG_fail;
{
try {
result = (void **)void_ptrptr_generator();
}
catch (...)
{
SWIG_fail;
}
}
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 );
return resultobj;
fail:
return NULL;
}
static PyMethodDef SwigMethods[] = {
{ (char *)"new_CvRNG_Wrapper", _wrap_new_CvRNG_Wrapper, METH_VARARGS, (char *)"new_CvRNG_Wrapper(CvRNG val) -> CvRNG_Wrapper"},
{ (char *)"CvRNG_Wrapper_ptr", _wrap_CvRNG_Wrapper_ptr, METH_VARARGS, (char *)"CvRNG_Wrapper_ptr(CvRNG_Wrapper self) -> CvRNG"},
{ (char *)"CvRNG_Wrapper_ref", _wrap_CvRNG_Wrapper_ref, METH_VARARGS, (char *)"CvRNG_Wrapper_ref(CvRNG_Wrapper self) -> CvRNG"},
{ (char *)"CvRNG_Wrapper___eq__", _wrap_CvRNG_Wrapper___eq__, METH_VARARGS, (char *)"CvRNG_Wrapper___eq__(CvRNG_Wrapper self, CvRNG_Wrapper x) -> bool"},
{ (char *)"CvRNG_Wrapper___ne__", _wrap_CvRNG_Wrapper___ne__, METH_VARARGS, (char *)"CvRNG_Wrapper___ne__(CvRNG_Wrapper self, CvRNG_Wrapper x) -> bool"},
{ (char *)"delete_CvRNG_Wrapper", _wrap_delete_CvRNG_Wrapper, METH_VARARGS, (char *)"delete_CvRNG_Wrapper(CvRNG_Wrapper self)"},
{ (char *)"CvRNG_Wrapper_swigregister", CvRNG_Wrapper_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvSubdiv2DEdge_Wrapper", _wrap_new_CvSubdiv2DEdge_Wrapper, METH_VARARGS, (char *)"new_CvSubdiv2DEdge_Wrapper(CvSubdiv2DEdge val) -> CvSubdiv2DEdge_Wrapper"},
{ (char *)"CvSubdiv2DEdge_Wrapper_ptr", _wrap_CvSubdiv2DEdge_Wrapper_ptr, METH_VARARGS, (char *)"CvSubdiv2DEdge_Wrapper_ptr(CvSubdiv2DEdge_Wrapper self) -> CvSubdiv2DEdge"},
{ (char *)"CvSubdiv2DEdge_Wrapper_ref", _wrap_CvSubdiv2DEdge_Wrapper_ref, METH_VARARGS, (char *)"CvSubdiv2DEdge_Wrapper_ref(CvSubdiv2DEdge_Wrapper self) -> CvSubdiv2DEdge"},
{ (char *)"CvSubdiv2DEdge_Wrapper___eq__", _wrap_CvSubdiv2DEdge_Wrapper___eq__, METH_VARARGS, (char *)"CvSubdiv2DEdge_Wrapper___eq__(CvSubdiv2DEdge_Wrapper self, CvSubdiv2DEdge_Wrapper x) -> bool"},
{ (char *)"CvSubdiv2DEdge_Wrapper___ne__", _wrap_CvSubdiv2DEdge_Wrapper___ne__, METH_VARARGS, (char *)"CvSubdiv2DEdge_Wrapper___ne__(CvSubdiv2DEdge_Wrapper self, CvSubdiv2DEdge_Wrapper x) -> bool"},
{ (char *)"delete_CvSubdiv2DEdge_Wrapper", _wrap_delete_CvSubdiv2DEdge_Wrapper, METH_VARARGS, (char *)"delete_CvSubdiv2DEdge_Wrapper(CvSubdiv2DEdge_Wrapper self)"},
{ (char *)"CvSubdiv2DEdge_Wrapper_swigregister", CvSubdiv2DEdge_Wrapper_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, (char *)"delete_PySwigIterator(PySwigIterator self)"},
{ (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, (char *)"PySwigIterator_value(PySwigIterator self) -> PyObject"},
{ (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, (char *)"\n"
"incr(size_t n=1) -> PySwigIterator\n"
"PySwigIterator_incr(PySwigIterator self) -> PySwigIterator\n"
""},
{ (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, (char *)"\n"
"decr(size_t n=1) -> PySwigIterator\n"
"PySwigIterator_decr(PySwigIterator self) -> PySwigIterator\n"
""},
{ (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, (char *)"PySwigIterator_distance(PySwigIterator self, PySwigIterator x) -> ptrdiff_t"},
{ (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, (char *)"PySwigIterator_equal(PySwigIterator self, PySwigIterator x) -> bool"},
{ (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, (char *)"PySwigIterator_copy(PySwigIterator self) -> PySwigIterator"},
{ (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, (char *)"PySwigIterator_next(PySwigIterator self) -> PyObject"},
{ (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, (char *)"PySwigIterator_previous(PySwigIterator self) -> PyObject"},
{ (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, (char *)"PySwigIterator_advance(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
{ (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, (char *)"PySwigIterator___eq__(PySwigIterator self, PySwigIterator x) -> bool"},
{ (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, (char *)"PySwigIterator___ne__(PySwigIterator self, PySwigIterator x) -> bool"},
{ (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, (char *)"PySwigIterator___iadd__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
{ (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, (char *)"PySwigIterator___isub__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
{ (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, (char *)"PySwigIterator___add__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
{ (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, (char *)"\n"
"__sub__(ptrdiff_t n) -> PySwigIterator\n"
"PySwigIterator___sub__(PySwigIterator self, PySwigIterator x) -> ptrdiff_t\n"
""},
{ (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"FloatVector_iterator", _wrap_FloatVector_iterator, METH_VARARGS, (char *)"FloatVector_iterator(FloatVector self, PyObject PYTHON_SELF) -> PySwigIterator"},
{ (char *)"FloatVector___nonzero__", _wrap_FloatVector___nonzero__, METH_VARARGS, (char *)"FloatVector___nonzero__(FloatVector self) -> bool"},
{ (char *)"FloatVector___len__", _wrap_FloatVector___len__, METH_VARARGS, (char *)"FloatVector___len__(FloatVector self) -> size_type"},
{ (char *)"FloatVector_pop", _wrap_FloatVector_pop, METH_VARARGS, (char *)"FloatVector_pop(FloatVector self) -> value_type"},
{ (char *)"FloatVector___getslice__", _wrap_FloatVector___getslice__, METH_VARARGS, (char *)"FloatVector___getslice__(FloatVector self, difference_type i, difference_type j) -> FloatVector"},
{ (char *)"FloatVector___setslice__", _wrap_FloatVector___setslice__, METH_VARARGS, (char *)"\n"
"FloatVector___setslice__(FloatVector self, difference_type i, difference_type j, \n"
" FloatVector v)\n"
""},
{ (char *)"FloatVector___delslice__", _wrap_FloatVector___delslice__, METH_VARARGS, (char *)"FloatVector___delslice__(FloatVector self, difference_type i, difference_type j)"},
{ (char *)"FloatVector___delitem__", _wrap_FloatVector___delitem__, METH_VARARGS, (char *)"FloatVector___delitem__(FloatVector self, difference_type i)"},
{ (char *)"FloatVector___getitem__", _wrap_FloatVector___getitem__, METH_VARARGS, (char *)"FloatVector___getitem__(FloatVector self, difference_type i) -> value_type"},
{ (char *)"FloatVector___setitem__", _wrap_FloatVector___setitem__, METH_VARARGS, (char *)"FloatVector___setitem__(FloatVector self, difference_type i, value_type x)"},
{ (char *)"FloatVector_append", _wrap_FloatVector_append, METH_VARARGS, (char *)"FloatVector_append(FloatVector self, value_type x)"},
{ (char *)"FloatVector_empty", _wrap_FloatVector_empty, METH_VARARGS, (char *)"FloatVector_empty(FloatVector self) -> bool"},
{ (char *)"FloatVector_size", _wrap_FloatVector_size, METH_VARARGS, (char *)"FloatVector_size(FloatVector self) -> size_type"},
{ (char *)"FloatVector_clear", _wrap_FloatVector_clear, METH_VARARGS, (char *)"FloatVector_clear(FloatVector self)"},
{ (char *)"FloatVector_swap", _wrap_FloatVector_swap, METH_VARARGS, (char *)"FloatVector_swap(FloatVector self, FloatVector v)"},
{ (char *)"FloatVector_get_allocator", _wrap_FloatVector_get_allocator, METH_VARARGS, (char *)"FloatVector_get_allocator(FloatVector self) -> allocator_type"},
{ (char *)"FloatVector_begin", _wrap_FloatVector_begin, METH_VARARGS, (char *)"FloatVector_begin(FloatVector self) -> const_iterator"},
{ (char *)"FloatVector_end", _wrap_FloatVector_end, METH_VARARGS, (char *)"FloatVector_end(FloatVector self) -> const_iterator"},
{ (char *)"FloatVector_rbegin", _wrap_FloatVector_rbegin, METH_VARARGS, (char *)"FloatVector_rbegin(FloatVector self) -> const_reverse_iterator"},
{ (char *)"FloatVector_rend", _wrap_FloatVector_rend, METH_VARARGS, (char *)"FloatVector_rend(FloatVector self) -> const_reverse_iterator"},
{ (char *)"FloatVector_pop_back", _wrap_FloatVector_pop_back, METH_VARARGS, (char *)"FloatVector_pop_back(FloatVector self)"},
{ (char *)"FloatVector_erase", _wrap_FloatVector_erase, METH_VARARGS, (char *)"\n"
"erase(iterator pos) -> iterator\n"
"FloatVector_erase(FloatVector self, iterator first, iterator last) -> iterator\n"
""},
{ (char *)"new_FloatVector", _wrap_new_FloatVector, METH_VARARGS, (char *)"\n"
"FloatVector()\n"
"FloatVector(FloatVector ?)\n"
"FloatVector(size_type size)\n"
"new_FloatVector(size_type size, value_type value) -> FloatVector\n"
""},
{ (char *)"FloatVector_push_back", _wrap_FloatVector_push_back, METH_VARARGS, (char *)"FloatVector_push_back(FloatVector self, value_type x)"},
{ (char *)"FloatVector_front", _wrap_FloatVector_front, METH_VARARGS, (char *)"FloatVector_front(FloatVector self) -> value_type"},
{ (char *)"FloatVector_back", _wrap_FloatVector_back, METH_VARARGS, (char *)"FloatVector_back(FloatVector self) -> value_type"},
{ (char *)"FloatVector_assign", _wrap_FloatVector_assign, METH_VARARGS, (char *)"FloatVector_assign(FloatVector self, size_type n, value_type x)"},
{ (char *)"FloatVector_resize", _wrap_FloatVector_resize, METH_VARARGS, (char *)"\n"
"resize(size_type new_size)\n"
"FloatVector_resize(FloatVector self, size_type new_size, value_type x)\n"
""},
{ (char *)"FloatVector_insert", _wrap_FloatVector_insert, METH_VARARGS, (char *)"\n"
"insert(iterator pos, value_type x) -> iterator\n"
"FloatVector_insert(FloatVector self, iterator pos, size_type n, value_type x)\n"
""},
{ (char *)"FloatVector_reserve", _wrap_FloatVector_reserve, METH_VARARGS, (char *)"FloatVector_reserve(FloatVector self, size_type n)"},
{ (char *)"FloatVector_capacity", _wrap_FloatVector_capacity, METH_VARARGS, (char *)"FloatVector_capacity(FloatVector self) -> size_type"},
{ (char *)"delete_FloatVector", _wrap_delete_FloatVector, METH_VARARGS, (char *)"delete_FloatVector(FloatVector self)"},
{ (char *)"FloatVector_swigregister", FloatVector_swigregister, METH_VARARGS, NULL},
{ (char *)"CvPointVector_iterator", _wrap_CvPointVector_iterator, METH_VARARGS, (char *)"CvPointVector_iterator(CvPointVector self, PyObject PYTHON_SELF) -> PySwigIterator"},
{ (char *)"CvPointVector___nonzero__", _wrap_CvPointVector___nonzero__, METH_VARARGS, (char *)"CvPointVector___nonzero__(CvPointVector self) -> bool"},
{ (char *)"CvPointVector___len__", _wrap_CvPointVector___len__, METH_VARARGS, (char *)"CvPointVector___len__(CvPointVector self) -> size_type"},
{ (char *)"CvPointVector_pop", _wrap_CvPointVector_pop, METH_VARARGS, (char *)"CvPointVector_pop(CvPointVector self) -> value_type"},
{ (char *)"CvPointVector___getslice__", _wrap_CvPointVector___getslice__, METH_VARARGS, (char *)"CvPointVector___getslice__(CvPointVector self, difference_type i, difference_type j) -> CvPointVector"},
{ (char *)"CvPointVector___setslice__", _wrap_CvPointVector___setslice__, METH_VARARGS, (char *)"\n"
"CvPointVector___setslice__(CvPointVector self, difference_type i, difference_type j, \n"
" CvPointVector v)\n"
""},
{ (char *)"CvPointVector___delslice__", _wrap_CvPointVector___delslice__, METH_VARARGS, (char *)"CvPointVector___delslice__(CvPointVector self, difference_type i, difference_type j)"},
{ (char *)"CvPointVector___delitem__", _wrap_CvPointVector___delitem__, METH_VARARGS, (char *)"CvPointVector___delitem__(CvPointVector self, difference_type i)"},
{ (char *)"CvPointVector___getitem__", _wrap_CvPointVector___getitem__, METH_VARARGS, (char *)"CvPointVector___getitem__(CvPointVector self, difference_type i) -> value_type"},
{ (char *)"CvPointVector___setitem__", _wrap_CvPointVector___setitem__, METH_VARARGS, (char *)"CvPointVector___setitem__(CvPointVector self, difference_type i, value_type x)"},
{ (char *)"CvPointVector_append", _wrap_CvPointVector_append, METH_VARARGS, (char *)"CvPointVector_append(CvPointVector self, value_type x)"},
{ (char *)"CvPointVector_empty", _wrap_CvPointVector_empty, METH_VARARGS, (char *)"CvPointVector_empty(CvPointVector self) -> bool"},
{ (char *)"CvPointVector_size", _wrap_CvPointVector_size, METH_VARARGS, (char *)"CvPointVector_size(CvPointVector self) -> size_type"},
{ (char *)"CvPointVector_clear", _wrap_CvPointVector_clear, METH_VARARGS, (char *)"CvPointVector_clear(CvPointVector self)"},
{ (char *)"CvPointVector_swap", _wrap_CvPointVector_swap, METH_VARARGS, (char *)"CvPointVector_swap(CvPointVector self, CvPointVector v)"},
{ (char *)"CvPointVector_get_allocator", _wrap_CvPointVector_get_allocator, METH_VARARGS, (char *)"CvPointVector_get_allocator(CvPointVector self) -> allocator_type"},
{ (char *)"CvPointVector_begin", _wrap_CvPointVector_begin, METH_VARARGS, (char *)"CvPointVector_begin(CvPointVector self) -> const_iterator"},
{ (char *)"CvPointVector_end", _wrap_CvPointVector_end, METH_VARARGS, (char *)"CvPointVector_end(CvPointVector self) -> const_iterator"},
{ (char *)"CvPointVector_rbegin", _wrap_CvPointVector_rbegin, METH_VARARGS, (char *)"CvPointVector_rbegin(CvPointVector self) -> const_reverse_iterator"},
{ (char *)"CvPointVector_rend", _wrap_CvPointVector_rend, METH_VARARGS, (char *)"CvPointVector_rend(CvPointVector self) -> const_reverse_iterator"},
{ (char *)"CvPointVector_pop_back", _wrap_CvPointVector_pop_back, METH_VARARGS, (char *)"CvPointVector_pop_back(CvPointVector self)"},
{ (char *)"CvPointVector_erase", _wrap_CvPointVector_erase, METH_VARARGS, (char *)"\n"
"erase(iterator pos) -> iterator\n"
"CvPointVector_erase(CvPointVector self, iterator first, iterator last) -> iterator\n"
""},
{ (char *)"new_CvPointVector", _wrap_new_CvPointVector, METH_VARARGS, (char *)"\n"
"CvPointVector()\n"
"CvPointVector(CvPointVector ?)\n"
"CvPointVector(size_type size)\n"
"new_CvPointVector(size_type size, value_type value) -> CvPointVector\n"
""},
{ (char *)"CvPointVector_push_back", _wrap_CvPointVector_push_back, METH_VARARGS, (char *)"CvPointVector_push_back(CvPointVector self, value_type x)"},
{ (char *)"CvPointVector_front", _wrap_CvPointVector_front, METH_VARARGS, (char *)"CvPointVector_front(CvPointVector self) -> value_type"},
{ (char *)"CvPointVector_back", _wrap_CvPointVector_back, METH_VARARGS, (char *)"CvPointVector_back(CvPointVector self) -> value_type"},
{ (char *)"CvPointVector_assign", _wrap_CvPointVector_assign, METH_VARARGS, (char *)"CvPointVector_assign(CvPointVector self, size_type n, value_type x)"},
{ (char *)"CvPointVector_resize", _wrap_CvPointVector_resize, METH_VARARGS, (char *)"\n"
"resize(size_type new_size)\n"
"CvPointVector_resize(CvPointVector self, size_type new_size, value_type x)\n"
""},
{ (char *)"CvPointVector_insert", _wrap_CvPointVector_insert, METH_VARARGS, (char *)"\n"
"insert(iterator pos, value_type x) -> iterator\n"
"CvPointVector_insert(CvPointVector self, iterator pos, size_type n, value_type x)\n"
""},
{ (char *)"CvPointVector_reserve", _wrap_CvPointVector_reserve, METH_VARARGS, (char *)"CvPointVector_reserve(CvPointVector self, size_type n)"},
{ (char *)"CvPointVector_capacity", _wrap_CvPointVector_capacity, METH_VARARGS, (char *)"CvPointVector_capacity(CvPointVector self) -> size_type"},
{ (char *)"delete_CvPointVector", _wrap_delete_CvPointVector, METH_VARARGS, (char *)"delete_CvPointVector(CvPointVector self)"},
{ (char *)"CvPointVector_swigregister", CvPointVector_swigregister, METH_VARARGS, NULL},
{ (char *)"cvCvtSeqToArray", _wrap_cvCvtSeqToArray, METH_VARARGS, (char *)"\n"
"cvCvtSeqToArray(CvSeq seq, CvArr elements, CvSlice slice=CV_WHOLE_SEQ) -> CvArr\n"
"cvCvtSeqToArray(CvSeq seq, CvArr elements) -> CvArr\n"
""},
{ (char *)"cvArcLength", _wrap_cvArcLength, METH_VARARGS, (char *)"\n"
"cvArcLength(CvSeq seq, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1) -> double\n"
"cvArcLength(CvSeq seq, CvSlice slice=CV_WHOLE_SEQ) -> double\n"
"cvArcLength(CvSeq seq) -> double\n"
"cvArcLength(CvArr arr, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1) -> double\n"
"cvArcLength(CvArr arr, CvSlice slice=CV_WHOLE_SEQ) -> double\n"
"cvArcLength(CvArr arr) -> double\n"
""},
{ (char *)"cvContourPerimeter", _wrap_cvContourPerimeter, METH_VARARGS, (char *)"\n"
"cvContourPerimeter(CvSeq seq) -> double\n"
"cvContourPerimeter(CvArr arr) -> double\n"
""},
{ (char *)"cvHaarDetectObjects", _wrap_cvHaarDetectObjects, METH_VARARGS, (char *)"\n"
"cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, \n"
" double scale_factor=1.1, int min_neighbors=3, \n"
" int flags=0, CvSize min_size=cvSize(0,0)) -> CvSeq_CvRect\n"
"cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, \n"
" double scale_factor=1.1, int min_neighbors=3, \n"
" int flags=0) -> CvSeq_CvRect\n"
"cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, \n"
" double scale_factor=1.1, int min_neighbors=3) -> CvSeq_CvRect\n"
"cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, \n"
" double scale_factor=1.1) -> CvSeq_CvRect\n"
"cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage) -> CvSeq_CvRect\n"
""},
{ (char *)"cvSegmentMotion", _wrap_cvSegmentMotion, METH_VARARGS, (char *)"\n"
"cvSegmentMotion(CvArr mhi, CvArr seg_mask, CvMemStorage storage, double timestamp, \n"
" double seg_thresh) -> CvSeq_CvConnectedComp\n"
""},
{ (char *)"cvApproxPoly", _wrap_cvApproxPoly, METH_VARARGS, (char *)"\n"
"cvApproxPoly(void src_seq, int header_size, CvMemStorage storage, \n"
" int method, double parameter, int parameter2=0) -> CvSeq_CvPoint\n"
"cvApproxPoly(void src_seq, int header_size, CvMemStorage storage, \n"
" int method, double parameter) -> CvSeq_CvPoint\n"
""},
{ (char *)"cvConvexHull2", _wrap_cvConvexHull2, METH_VARARGS, (char *)"\n"
"cvConvexHull2(CvArr points, int orientation=CV_CLOCKWISE, int return_points=0) -> CvMat\n"
"cvConvexHull2(CvArr points, int orientation=CV_CLOCKWISE) -> CvMat\n"
"cvConvexHull2(CvArr points) -> CvMat\n"
""},
{ (char *)"cvSnakeImage", _wrap_cvSnakeImage, METH_VARARGS, (char *)"\n"
"cvSnakeImage(CvMat image, CvPointVector points, FloatVector alpha, \n"
" FloatVector beta, FloatVector gamma, CvSize win, \n"
" CvTermCriteria criteria, int calc_gradient=1) -> CvPointVector\n"
"cvSnakeImage(CvMat image, CvPointVector points, FloatVector alpha, \n"
" FloatVector beta, FloatVector gamma, CvSize win, \n"
" CvTermCriteria criteria) -> CvPointVector\n"
""},
{ (char *)"cvReleaseImage", _wrap_cvReleaseImage, METH_VARARGS, (char *)"cvReleaseImage(PyObject obj)"},
{ (char *)"cvReleaseMat", _wrap_cvReleaseMat, METH_VARARGS, (char *)"cvReleaseMat(PyObject obj)"},
{ (char *)"cvReleaseStructuringElement", _wrap_cvReleaseStructuringElement, METH_VARARGS, (char *)"cvReleaseStructuringElement(PyObject obj)"},
{ (char *)"cvReleaseConDensation", _wrap_cvReleaseConDensation, METH_VARARGS, (char *)"cvReleaseConDensation(PyObject obj)"},
{ (char *)"cvReleaseKalman", _wrap_cvReleaseKalman, METH_VARARGS, (char *)"cvReleaseKalman(PyObject obj)"},
{ (char *)"cvReleaseHist", _wrap_cvReleaseHist, METH_VARARGS, (char *)"cvReleaseHist(PyObject obj)"},
{ (char *)"cvReleaseHaarClassifierCascade", _wrap_cvReleaseHaarClassifierCascade, METH_VARARGS, (char *)"cvReleaseHaarClassifierCascade(PyObject obj)"},
{ (char *)"cvReleasePOSITObject", _wrap_cvReleasePOSITObject, METH_VARARGS, (char *)"cvReleasePOSITObject(PyObject obj)"},
{ (char *)"cvReleaseImageHeader", _wrap_cvReleaseImageHeader, METH_VARARGS, (char *)"cvReleaseImageHeader(PyObject obj)"},
{ (char *)"cvReleaseMatND", _wrap_cvReleaseMatND, METH_VARARGS, (char *)"cvReleaseMatND(PyObject obj)"},
{ (char *)"cvReleaseSparseMat", _wrap_cvReleaseSparseMat, METH_VARARGS, (char *)"cvReleaseSparseMat(PyObject obj)"},
{ (char *)"cvReleaseMemStorage", _wrap_cvReleaseMemStorage, METH_VARARGS, (char *)"cvReleaseMemStorage(PyObject obj)"},
{ (char *)"cvReleaseGraphScanner", _wrap_cvReleaseGraphScanner, METH_VARARGS, (char *)"cvReleaseGraphScanner(PyObject obj)"},
{ (char *)"cvReleaseFileStorage", _wrap_cvReleaseFileStorage, METH_VARARGS, (char *)"cvReleaseFileStorage(PyObject obj)"},
{ (char *)"cvRelease", _wrap_cvRelease, METH_VARARGS, (char *)"cvRelease(PyObject obj)"},
{ (char *)"cvReleaseCapture", _wrap_cvReleaseCapture, METH_VARARGS, (char *)"cvReleaseCapture(PyObject obj)"},
{ (char *)"cvReleaseVideoWriter", _wrap_cvReleaseVideoWriter, METH_VARARGS, (char *)"cvReleaseVideoWriter(PyObject obj)"},
{ (char *)"cvFree", _wrap_cvFree, METH_VARARGS, (char *)"cvFree(void ptr)"},
{ (char *)"CV_READ_CHAIN_POINT", _wrap_CV_READ_CHAIN_POINT, METH_VARARGS, (char *)"CV_READ_CHAIN_POINT(CvPoint _pt, CvChainPtReader reader)"},
{ (char *)"CV_MAT_ELEM_PTR", _wrap_CV_MAT_ELEM_PTR, METH_VARARGS, (char *)"CV_MAT_ELEM_PTR(CvMat mat, int row, int col) -> void"},
{ (char *)"CV_MAT_ELEM_PTR_FAST", _wrap_CV_MAT_ELEM_PTR_FAST, METH_VARARGS, (char *)"CV_MAT_ELEM_PTR_FAST(CvMat mat, int row, int col, int pix_size) -> void"},
{ (char *)"CV_NODE_VAL", _wrap_CV_NODE_VAL, METH_VARARGS, (char *)"CV_NODE_VAL(CvSparseMat mat, CvSparseNode node) -> void"},
{ (char *)"CV_NODE_IDX", _wrap_CV_NODE_IDX, METH_VARARGS, (char *)"CV_NODE_IDX(CvSparseMat mat, CvSparseNode node) -> int"},
{ (char *)"CV_SUBDIV2D_NEXT_EDGE", _wrap_CV_SUBDIV2D_NEXT_EDGE, METH_VARARGS, (char *)"CV_SUBDIV2D_NEXT_EDGE(CvSubdiv2DEdge edge) -> CvQuadEdge2D"},
{ (char *)"CV_SWAP", _wrap_CV_SWAP, METH_VARARGS, (char *)"CV_SWAP(int a, int b, int t)"},
{ (char *)"CV_IMIN", _wrap_CV_IMIN, METH_VARARGS, (char *)"CV_IMIN(int a, int b) -> int"},
{ (char *)"CV_IMAX", _wrap_CV_IMAX, METH_VARARGS, (char *)"CV_IMAX(int a, int b) -> int"},
{ (char *)"CV_IABS", _wrap_CV_IABS, METH_VARARGS, (char *)"CV_IABS(int a) -> int"},
{ (char *)"CV_CMP", _wrap_CV_CMP, METH_VARARGS, (char *)"CV_CMP(int a, int b)"},
{ (char *)"CV_SIGN", _wrap_CV_SIGN, METH_VARARGS, (char *)"CV_SIGN(int a)"},
{ (char *)"cvInvSqrt", _wrap_cvInvSqrt, METH_VARARGS, (char *)"cvInvSqrt(double value)"},
{ (char *)"cvSqrt", _wrap_cvSqrt, METH_VARARGS, (char *)"cvSqrt(double value)"},
{ (char *)"CV_IS_IMAGE_HDR", _wrap_CV_IS_IMAGE_HDR, METH_VARARGS, (char *)"CV_IS_IMAGE_HDR(CvArr img) -> int"},
{ (char *)"CV_IS_IMAGE", _wrap_CV_IS_IMAGE, METH_VARARGS, (char *)"CV_IS_IMAGE(CvArr img) -> int"},
{ (char *)"CV_MAKETYPE", _wrap_CV_MAKETYPE, METH_VARARGS, (char *)"CV_MAKETYPE(int depth, int cn) -> int"},
{ (char *)"CV_8UC", _wrap_CV_8UC, METH_VARARGS, (char *)"CV_8UC(int n) -> int"},
{ (char *)"CV_8SC", _wrap_CV_8SC, METH_VARARGS, (char *)"CV_8SC(int n) -> int"},
{ (char *)"CV_16UC", _wrap_CV_16UC, METH_VARARGS, (char *)"CV_16UC(int n) -> int"},
{ (char *)"CV_16SC", _wrap_CV_16SC, METH_VARARGS, (char *)"CV_16SC(int n) -> int"},
{ (char *)"CV_32SC", _wrap_CV_32SC, METH_VARARGS, (char *)"CV_32SC(int n) -> int"},
{ (char *)"CV_32FC", _wrap_CV_32FC, METH_VARARGS, (char *)"CV_32FC(int n) -> int"},
{ (char *)"CV_64FC", _wrap_CV_64FC, METH_VARARGS, (char *)"CV_64FC(int n) -> int"},
{ (char *)"CV_MAT_CN", _wrap_CV_MAT_CN, METH_VARARGS, (char *)"CV_MAT_CN(int flags) -> int"},
{ (char *)"CV_MAT_DEPTH", _wrap_CV_MAT_DEPTH, METH_VARARGS, (char *)"CV_MAT_DEPTH(int flags) -> int"},
{ (char *)"CV_MAT_TYPE", _wrap_CV_MAT_TYPE, METH_VARARGS, (char *)"CV_MAT_TYPE(int flags) -> int"},
{ (char *)"CV_IS_MAT_CONT", _wrap_CV_IS_MAT_CONT, METH_VARARGS, (char *)"CV_IS_MAT_CONT(int flags) -> int"},
{ (char *)"CV_IS_TEMP_MAT", _wrap_CV_IS_TEMP_MAT, METH_VARARGS, (char *)"CV_IS_TEMP_MAT(int flags) -> int"},
{ (char *)"CV_IS_MAT_HDR", _wrap_CV_IS_MAT_HDR, METH_VARARGS, (char *)"CV_IS_MAT_HDR(CvMat mat) -> int"},
{ (char *)"CV_IS_MAT", _wrap_CV_IS_MAT, METH_VARARGS, (char *)"CV_IS_MAT(CvMat mat) -> int"},
{ (char *)"CV_IS_MASK_ARR", _wrap_CV_IS_MASK_ARR, METH_VARARGS, (char *)"CV_IS_MASK_ARR(CvMat mat) -> int"},
{ (char *)"CV_ARE_TYPES_EQ", _wrap_CV_ARE_TYPES_EQ, METH_VARARGS, (char *)"CV_ARE_TYPES_EQ(CvMat mat1, CvMat mat2) -> int"},
{ (char *)"CV_ARE_CNS_EQ", _wrap_CV_ARE_CNS_EQ, METH_VARARGS, (char *)"CV_ARE_CNS_EQ(CvMat mat1, CvMat mat2) -> int"},
{ (char *)"CV_ARE_DEPTHS_EQ", _wrap_CV_ARE_DEPTHS_EQ, METH_VARARGS, (char *)"CV_ARE_DEPTHS_EQ(CvMat mat1, CvMat mat2) -> int"},
{ (char *)"CV_ARE_SIZES_EQ", _wrap_CV_ARE_SIZES_EQ, METH_VARARGS, (char *)"CV_ARE_SIZES_EQ(CvMat mat1, CvMat mat2) -> int"},
{ (char *)"CV_IS_MAT_CONST", _wrap_CV_IS_MAT_CONST, METH_VARARGS, (char *)"CV_IS_MAT_CONST(CvMat mat) -> int"},
{ (char *)"CV_ELEM_SIZE1", _wrap_CV_ELEM_SIZE1, METH_VARARGS, (char *)"CV_ELEM_SIZE1(int type) -> int"},
{ (char *)"CV_ELEM_SIZE", _wrap_CV_ELEM_SIZE, METH_VARARGS, (char *)"CV_ELEM_SIZE(int type) -> int"},
{ (char *)"CV_IS_MATND_HDR", _wrap_CV_IS_MATND_HDR, METH_VARARGS, (char *)"CV_IS_MATND_HDR(CvMat mat) -> int"},
{ (char *)"CV_IS_MATND", _wrap_CV_IS_MATND, METH_VARARGS, (char *)"CV_IS_MATND(CvMat mat) -> int"},
{ (char *)"CV_IS_SPARSE_MAT_HDR", _wrap_CV_IS_SPARSE_MAT_HDR, METH_VARARGS, (char *)"CV_IS_SPARSE_MAT_HDR(CvMat mat) -> int"},
{ (char *)"CV_IS_SPARSE_MAT", _wrap_CV_IS_SPARSE_MAT, METH_VARARGS, (char *)"CV_IS_SPARSE_MAT(CvMat mat) -> int"},
{ (char *)"CV_IS_HIST", _wrap_CV_IS_HIST, METH_VARARGS, (char *)"CV_IS_HIST(CvHistogram hist) -> int"},
{ (char *)"CV_IS_UNIFORM_HIST", _wrap_CV_IS_UNIFORM_HIST, METH_VARARGS, (char *)"CV_IS_UNIFORM_HIST(CvHistogram hist) -> int"},
{ (char *)"CV_IS_SPARSE_HIST", _wrap_CV_IS_SPARSE_HIST, METH_VARARGS, (char *)"CV_IS_SPARSE_HIST(CvHistogram hist) -> int"},
{ (char *)"CV_HIST_HAS_RANGES", _wrap_CV_HIST_HAS_RANGES, METH_VARARGS, (char *)"CV_HIST_HAS_RANGES(CvHistogram hist) -> int"},
{ (char *)"CV_IS_STORAGE", _wrap_CV_IS_STORAGE, METH_VARARGS, (char *)"CV_IS_STORAGE(CvMemStorage storage) -> int"},
{ (char *)"CV_IS_SET_ELEM", _wrap_CV_IS_SET_ELEM, METH_VARARGS, (char *)"CV_IS_SET_ELEM(void ptr) -> int"},
{ (char *)"CV_IS_SEQ", _wrap_CV_IS_SEQ, METH_VARARGS, (char *)"CV_IS_SEQ(CvSeq seq) -> int"},
{ (char *)"CV_IS_SET", _wrap_CV_IS_SET, METH_VARARGS, (char *)"CV_IS_SET(CvSet set) -> int"},
{ (char *)"CV_SEQ_ELTYPE", _wrap_CV_SEQ_ELTYPE, METH_VARARGS, (char *)"CV_SEQ_ELTYPE(CvSeq seq) -> int"},
{ (char *)"CV_SEQ_KIND", _wrap_CV_SEQ_KIND, METH_VARARGS, (char *)"CV_SEQ_KIND(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_INDEX", _wrap_CV_IS_SEQ_INDEX, METH_VARARGS, (char *)"CV_IS_SEQ_INDEX(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CURVE", _wrap_CV_IS_SEQ_CURVE, METH_VARARGS, (char *)"CV_IS_SEQ_CURVE(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CLOSED", _wrap_CV_IS_SEQ_CLOSED, METH_VARARGS, (char *)"CV_IS_SEQ_CLOSED(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CONVEX", _wrap_CV_IS_SEQ_CONVEX, METH_VARARGS, (char *)"CV_IS_SEQ_CONVEX(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_HOLE", _wrap_CV_IS_SEQ_HOLE, METH_VARARGS, (char *)"CV_IS_SEQ_HOLE(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_SIMPLE", _wrap_CV_IS_SEQ_SIMPLE, METH_VARARGS, (char *)"CV_IS_SEQ_SIMPLE(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_POINT_SET", _wrap_CV_IS_SEQ_POINT_SET, METH_VARARGS, (char *)"CV_IS_SEQ_POINT_SET(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_POINT_SUBSET", _wrap_CV_IS_SEQ_POINT_SUBSET, METH_VARARGS, (char *)"CV_IS_SEQ_POINT_SUBSET(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_POLYLINE", _wrap_CV_IS_SEQ_POLYLINE, METH_VARARGS, (char *)"CV_IS_SEQ_POLYLINE(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_POLYGON", _wrap_CV_IS_SEQ_POLYGON, METH_VARARGS, (char *)"CV_IS_SEQ_POLYGON(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CHAIN", _wrap_CV_IS_SEQ_CHAIN, METH_VARARGS, (char *)"CV_IS_SEQ_CHAIN(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CONTOUR", _wrap_CV_IS_SEQ_CONTOUR, METH_VARARGS, (char *)"CV_IS_SEQ_CONTOUR(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_CHAIN_CONTOUR", _wrap_CV_IS_SEQ_CHAIN_CONTOUR, METH_VARARGS, (char *)"CV_IS_SEQ_CHAIN_CONTOUR(CvSeq seq) -> int"},
{ (char *)"CV_IS_SEQ_POLYGON_TREE", _wrap_CV_IS_SEQ_POLYGON_TREE, METH_VARARGS, (char *)"CV_IS_SEQ_POLYGON_TREE(CvSeq seq) -> int"},
{ (char *)"CV_IS_GRAPH", _wrap_CV_IS_GRAPH, METH_VARARGS, (char *)"CV_IS_GRAPH(CvSeq seq) -> int"},
{ (char *)"CV_IS_GRAPH_ORIENTED", _wrap_CV_IS_GRAPH_ORIENTED, METH_VARARGS, (char *)"CV_IS_GRAPH_ORIENTED(CvSeq seq) -> int"},
{ (char *)"CV_IS_SUBDIV2D", _wrap_CV_IS_SUBDIV2D, METH_VARARGS, (char *)"CV_IS_SUBDIV2D(CvSeq seq) -> int"},
{ (char *)"CV_WRITE_SEQ_ELEM_VAR", _wrap_CV_WRITE_SEQ_ELEM_VAR, METH_VARARGS, (char *)"CV_WRITE_SEQ_ELEM_VAR(void elem_ptr, CvSeqWriter writer)"},
{ (char *)"CV_WRITE_SEQ_ELEM", _wrap_CV_WRITE_SEQ_ELEM, METH_VARARGS, (char *)"CV_WRITE_SEQ_ELEM(CvPoint elem, CvSeqWriter writer)"},
{ (char *)"CV_NEXT_SEQ_ELEM", _wrap_CV_NEXT_SEQ_ELEM, METH_VARARGS, (char *)"CV_NEXT_SEQ_ELEM(int elem_size, CvSeqReader reader)"},
{ (char *)"CV_PREV_SEQ_ELEM", _wrap_CV_PREV_SEQ_ELEM, METH_VARARGS, (char *)"CV_PREV_SEQ_ELEM(int elem_size, CvSeqReader reader)"},
{ (char *)"CV_READ_SEQ_ELEM", _wrap_CV_READ_SEQ_ELEM, METH_VARARGS, (char *)"CV_READ_SEQ_ELEM(CvPoint elem, CvSeqReader reader)"},
{ (char *)"CV_REV_READ_SEQ_ELEM", _wrap_CV_REV_READ_SEQ_ELEM, METH_VARARGS, (char *)"CV_REV_READ_SEQ_ELEM(CvPoint elem, CvSeqReader reader)"},
{ (char *)"CV_CURRENT_POINT", _wrap_CV_CURRENT_POINT, METH_VARARGS, (char *)"CV_CURRENT_POINT(CvSeqReader reader) -> CvPoint"},
{ (char *)"CV_PREV_POINT", _wrap_CV_PREV_POINT, METH_VARARGS, (char *)"CV_PREV_POINT(CvSeqReader reader) -> CvPoint"},
{ (char *)"CV_READ_EDGE", _wrap_CV_READ_EDGE, METH_VARARGS, (char *)"CV_READ_EDGE(CvPoint pt1, CvPoint pt2, CvSeqReader reader)"},
{ (char *)"CV_NEXT_GRAPH_EDGE", _wrap_CV_NEXT_GRAPH_EDGE, METH_VARARGS, (char *)"CV_NEXT_GRAPH_EDGE(CvGraphEdge edge, CvGraphVtx vertex) -> CvGraphEdge"},
{ (char *)"CV_NODE_TYPE", _wrap_CV_NODE_TYPE, METH_VARARGS, (char *)"CV_NODE_TYPE(int flags) -> int"},
{ (char *)"CV_NODE_IS_INT", _wrap_CV_NODE_IS_INT, METH_VARARGS, (char *)"CV_NODE_IS_INT(int flags) -> int"},
{ (char *)"CV_NODE_IS_REAL", _wrap_CV_NODE_IS_REAL, METH_VARARGS, (char *)"CV_NODE_IS_REAL(int flags) -> int"},
{ (char *)"CV_NODE_IS_STRING", _wrap_CV_NODE_IS_STRING, METH_VARARGS, (char *)"CV_NODE_IS_STRING(int flags) -> int"},
{ (char *)"CV_NODE_IS_SEQ", _wrap_CV_NODE_IS_SEQ, METH_VARARGS, (char *)"CV_NODE_IS_SEQ(int flags) -> int"},
{ (char *)"CV_NODE_IS_MAP", _wrap_CV_NODE_IS_MAP, METH_VARARGS, (char *)"CV_NODE_IS_MAP(int flags) -> int"},
{ (char *)"CV_NODE_IS_COLLECTION", _wrap_CV_NODE_IS_COLLECTION, METH_VARARGS, (char *)"CV_NODE_IS_COLLECTION(int flags) -> int"},
{ (char *)"CV_NODE_IS_FLOW", _wrap_CV_NODE_IS_FLOW, METH_VARARGS, (char *)"CV_NODE_IS_FLOW(int flags) -> int"},
{ (char *)"CV_NODE_IS_EMPTY", _wrap_CV_NODE_IS_EMPTY, METH_VARARGS, (char *)"CV_NODE_IS_EMPTY(int flags) -> int"},
{ (char *)"CV_NODE_IS_USER", _wrap_CV_NODE_IS_USER, METH_VARARGS, (char *)"CV_NODE_IS_USER(int flags) -> int"},
{ (char *)"CV_NODE_HAS_NAME", _wrap_CV_NODE_HAS_NAME, METH_VARARGS, (char *)"CV_NODE_HAS_NAME(int flags) -> int"},
{ (char *)"CV_NODE_SEQ_IS_SIMPLE", _wrap_CV_NODE_SEQ_IS_SIMPLE, METH_VARARGS, (char *)"CV_NODE_SEQ_IS_SIMPLE(CvSeq seq) -> int"},
{ (char *)"cvReshapeND", _wrap_cvReshapeND, METH_VARARGS, (char *)"\n"
"cvReshapeND(CvArr arr, CvMat header, int new_cn, int new_dims, \n"
" int new_sizes)\n"
""},
{ (char *)"cvConvert", _wrap_cvConvert, METH_VARARGS, (char *)"cvConvert(CvArr src, CvArr dst)"},
{ (char *)"cvAXPY", _wrap_cvAXPY, METH_VARARGS, (char *)"cvAXPY(CvArr A, double real_scalar, CvArr B, CvArr C)"},
{ (char *)"cvAbs", _wrap_cvAbs, METH_VARARGS, (char *)"cvAbs(CvArr src, CvArr dst)"},
{ (char *)"cvMatMulAdd", _wrap_cvMatMulAdd, METH_VARARGS, (char *)"cvMatMulAdd(CvArr src1, CvArr src2, CvArr src3, CvArr dst)"},
{ (char *)"cvMatMul", _wrap_cvMatMul, METH_VARARGS, (char *)"cvMatMul(CvArr src1, CvArr src2, CvArr dst)"},
{ (char *)"cvGetGraphVtx", _wrap_cvGetGraphVtx, METH_VARARGS, (char *)"cvGetGraphVtx(CvGraph graph, int idx)"},
{ (char *)"cvGraphVtxIdx", _wrap_cvGraphVtxIdx, METH_VARARGS, (char *)"cvGraphVtxIdx(CvGraph graph, CvGraphVtx vtx) -> int"},
{ (char *)"cvGraphEdgeIdx", _wrap_cvGraphEdgeIdx, METH_VARARGS, (char *)"cvGraphEdgeIdx(CvGraph graph, CvGraphEdge edge) -> int"},
{ (char *)"cvGraphGetVtxCount", _wrap_cvGraphGetVtxCount, METH_VARARGS, (char *)"cvGraphGetVtxCount(CvGraph graph) -> int"},
{ (char *)"cvGraphGetEdgeCount", _wrap_cvGraphGetEdgeCount, METH_VARARGS, (char *)"cvGraphGetEdgeCount(CvGraph graph) -> int"},
{ (char *)"CV_IS_GRAPH_VERTEX_VISITED", _wrap_CV_IS_GRAPH_VERTEX_VISITED, METH_VARARGS, (char *)"CV_IS_GRAPH_VERTEX_VISITED(CvGraphVtx vtx) -> int"},
{ (char *)"CV_IS_GRAPH_EDGE_VISITED", _wrap_CV_IS_GRAPH_EDGE_VISITED, METH_VARARGS, (char *)"CV_IS_GRAPH_EDGE_VISITED(CvGraphEdge edge) -> int"},
{ (char *)"CV_RGB", _wrap_CV_RGB, METH_VARARGS, (char *)"CV_RGB(double r, double g, int b) -> CvScalar"},
{ (char *)"CV_NEXT_LINE_POINT", _wrap_CV_NEXT_LINE_POINT, METH_VARARGS, (char *)"CV_NEXT_LINE_POINT(CvLineIterator line_iterator)"},
{ (char *)"CV_INIT_3X3_DELTAS", _wrap_CV_INIT_3X3_DELTAS, METH_VARARGS, (char *)"CV_INIT_3X3_DELTAS(double deltas, int step, int nch)"},
{ (char *)"CV_IS_HAAR_CLASSIFIER", _wrap_CV_IS_HAAR_CLASSIFIER, METH_VARARGS, (char *)"CV_IS_HAAR_CLASSIFIER(void haar) -> int"},
{ (char *)"cvCalcBackProject", _wrap_cvCalcBackProject, METH_VARARGS, (char *)"cvCalcBackProject( image, CvArr dst, CvHistogram hist)"},
{ (char *)"cvCalcBackProjectPatch", _wrap_cvCalcBackProjectPatch, METH_VARARGS, (char *)"\n"
"cvCalcBackProjectPatch( image, CvArr dst, CvSize range, CvHistogram hist, \n"
" int method, double factor)\n"
""},
{ (char *)"cvCreateImage", _wrap_cvCreateImage, METH_VARARGS, (char *)"cvCreateImage(CvSize size, int depth, int channels) -> CvMat"},
{ (char *)"cvCloneImage", _wrap_cvCloneImage, METH_VARARGS, (char *)"cvCloneImage(CvMat mat) -> CvMat"},
{ (char *)"Cv32suf_i_set", _wrap_Cv32suf_i_set, METH_VARARGS, (char *)"Cv32suf_i_set(Cv32suf self, int i)"},
{ (char *)"Cv32suf_i_get", _wrap_Cv32suf_i_get, METH_VARARGS, (char *)"Cv32suf_i_get(Cv32suf self) -> int"},
{ (char *)"Cv32suf_u_set", _wrap_Cv32suf_u_set, METH_VARARGS, (char *)"Cv32suf_u_set(Cv32suf self, unsigned int u)"},
{ (char *)"Cv32suf_u_get", _wrap_Cv32suf_u_get, METH_VARARGS, (char *)"Cv32suf_u_get(Cv32suf self) -> unsigned int"},
{ (char *)"Cv32suf_f_set", _wrap_Cv32suf_f_set, METH_VARARGS, (char *)"Cv32suf_f_set(Cv32suf self, float f)"},
{ (char *)"Cv32suf_f_get", _wrap_Cv32suf_f_get, METH_VARARGS, (char *)"Cv32suf_f_get(Cv32suf self) -> float"},
{ (char *)"new_Cv32suf", _wrap_new_Cv32suf, METH_VARARGS, (char *)"new_Cv32suf() -> Cv32suf"},
{ (char *)"delete_Cv32suf", _wrap_delete_Cv32suf, METH_VARARGS, (char *)"delete_Cv32suf(Cv32suf self)"},
{ (char *)"Cv32suf_swigregister", Cv32suf_swigregister, METH_VARARGS, NULL},
{ (char *)"Cv64suf_i_set", _wrap_Cv64suf_i_set, METH_VARARGS, (char *)"Cv64suf_i_set(Cv64suf self, int64 i)"},
{ (char *)"Cv64suf_i_get", _wrap_Cv64suf_i_get, METH_VARARGS, (char *)"Cv64suf_i_get(Cv64suf self) -> int64"},
{ (char *)"Cv64suf_u_set", _wrap_Cv64suf_u_set, METH_VARARGS, (char *)"Cv64suf_u_set(Cv64suf self, uint64 u)"},
{ (char *)"Cv64suf_u_get", _wrap_Cv64suf_u_get, METH_VARARGS, (char *)"Cv64suf_u_get(Cv64suf self) -> uint64"},
{ (char *)"Cv64suf_f_set", _wrap_Cv64suf_f_set, METH_VARARGS, (char *)"Cv64suf_f_set(Cv64suf self, double f)"},
{ (char *)"Cv64suf_f_get", _wrap_Cv64suf_f_get, METH_VARARGS, (char *)"Cv64suf_f_get(Cv64suf self) -> double"},
{ (char *)"new_Cv64suf", _wrap_new_Cv64suf, METH_VARARGS, (char *)"new_Cv64suf() -> Cv64suf"},
{ (char *)"delete_Cv64suf", _wrap_delete_Cv64suf, METH_VARARGS, (char *)"delete_Cv64suf(Cv64suf self)"},
{ (char *)"Cv64suf_swigregister", Cv64suf_swigregister, METH_VARARGS, NULL},
{ (char *)"cvRound", _wrap_cvRound, METH_VARARGS, (char *)"cvRound(double value) -> int"},
{ (char *)"cvFloor", _wrap_cvFloor, METH_VARARGS, (char *)"cvFloor(double value) -> int"},
{ (char *)"cvCeil", _wrap_cvCeil, METH_VARARGS, (char *)"cvCeil(double value) -> int"},
{ (char *)"cvIsNaN", _wrap_cvIsNaN, METH_VARARGS, (char *)"cvIsNaN(double value) -> int"},
{ (char *)"cvIsInf", _wrap_cvIsInf, METH_VARARGS, (char *)"cvIsInf(double value) -> int"},
{ (char *)"cvRNG", _wrap_cvRNG, METH_VARARGS, (char *)"\n"
"cvRNG(int64 seed=-1) -> CvRNG\n"
"cvRNG() -> CvRNG\n"
""},
{ (char *)"cvRandInt", _wrap_cvRandInt, METH_VARARGS, (char *)"cvRandInt(CvRNG rng) -> unsigned int"},
{ (char *)"cvRandReal", _wrap_cvRandReal, METH_VARARGS, (char *)"cvRandReal(CvRNG rng) -> double"},
{ (char *)"IplImage_ID_set", _wrap_IplImage_ID_set, METH_VARARGS, (char *)"IplImage_ID_set( self, int ID)"},
{ (char *)"IplImage_ID_get", _wrap_IplImage_ID_get, METH_VARARGS, (char *)"IplImage_ID_get( self) -> int"},
{ (char *)"IplImage_nChannels_set", _wrap_IplImage_nChannels_set, METH_VARARGS, (char *)"IplImage_nChannels_set( self, int nChannels)"},
{ (char *)"IplImage_nChannels_get", _wrap_IplImage_nChannels_get, METH_VARARGS, (char *)"IplImage_nChannels_get( self) -> int"},
{ (char *)"IplImage_depth_set", _wrap_IplImage_depth_set, METH_VARARGS, (char *)"IplImage_depth_set( self, int depth)"},
{ (char *)"IplImage_depth_get", _wrap_IplImage_depth_get, METH_VARARGS, (char *)"IplImage_depth_get( self) -> int"},
{ (char *)"IplImage_dataOrder_set", _wrap_IplImage_dataOrder_set, METH_VARARGS, (char *)"IplImage_dataOrder_set( self, int dataOrder)"},
{ (char *)"IplImage_dataOrder_get", _wrap_IplImage_dataOrder_get, METH_VARARGS, (char *)"IplImage_dataOrder_get( self) -> int"},
{ (char *)"IplImage_origin_set", _wrap_IplImage_origin_set, METH_VARARGS, (char *)"IplImage_origin_set( self, int origin)"},
{ (char *)"IplImage_origin_get", _wrap_IplImage_origin_get, METH_VARARGS, (char *)"IplImage_origin_get( self) -> int"},
{ (char *)"IplImage_align_set", _wrap_IplImage_align_set, METH_VARARGS, (char *)"IplImage_align_set( self, int align)"},
{ (char *)"IplImage_align_get", _wrap_IplImage_align_get, METH_VARARGS, (char *)"IplImage_align_get( self) -> int"},
{ (char *)"IplImage_width_set", _wrap_IplImage_width_set, METH_VARARGS, (char *)"IplImage_width_set( self, int width)"},
{ (char *)"IplImage_width_get", _wrap_IplImage_width_get, METH_VARARGS, (char *)"IplImage_width_get( self) -> int"},
{ (char *)"IplImage_height_set", _wrap_IplImage_height_set, METH_VARARGS, (char *)"IplImage_height_set( self, int height)"},
{ (char *)"IplImage_height_get", _wrap_IplImage_height_get, METH_VARARGS, (char *)"IplImage_height_get( self) -> int"},
{ (char *)"IplImage_roi_set", _wrap_IplImage_roi_set, METH_VARARGS, (char *)"IplImage_roi_set( self, IplROI roi)"},
{ (char *)"IplImage_roi_get", _wrap_IplImage_roi_get, METH_VARARGS, (char *)"IplImage_roi_get( self) -> IplROI"},
{ (char *)"IplImage_imageSize_set", _wrap_IplImage_imageSize_set, METH_VARARGS, (char *)"IplImage_imageSize_set( self, int imageSize)"},
{ (char *)"IplImage_imageSize_get", _wrap_IplImage_imageSize_get, METH_VARARGS, (char *)"IplImage_imageSize_get( self) -> int"},
{ (char *)"IplImage_widthStep_set", _wrap_IplImage_widthStep_set, METH_VARARGS, (char *)"IplImage_widthStep_set( self, int widthStep)"},
{ (char *)"IplImage_widthStep_get", _wrap_IplImage_widthStep_get, METH_VARARGS, (char *)"IplImage_widthStep_get( self) -> int"},
{ (char *)"delete_IplImage", _wrap_delete_IplImage, METH_VARARGS, (char *)"delete_IplImage( self)"},
{ (char *)"IplImage___add__", _wrap_IplImage___add__, METH_VARARGS, (char *)"\n"
"__add__(CvArr src)\n"
"IplImage___add__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___iadd__", _wrap_IplImage___iadd__, METH_VARARGS, (char *)"\n"
"__iadd__(CvArr src)\n"
"IplImage___iadd__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___xor__", _wrap_IplImage___xor__, METH_VARARGS, (char *)"\n"
"__xor__(CvArr src)\n"
"IplImage___xor__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___ixor__", _wrap_IplImage___ixor__, METH_VARARGS, (char *)"\n"
"__ixor__(CvArr src)\n"
"IplImage___ixor__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___sub__", _wrap_IplImage___sub__, METH_VARARGS, (char *)"\n"
"__sub__(CvArr src)\n"
"IplImage___sub__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___isub__", _wrap_IplImage___isub__, METH_VARARGS, (char *)"\n"
"__isub__(CvArr src)\n"
"IplImage___isub__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___or__", _wrap_IplImage___or__, METH_VARARGS, (char *)"\n"
"__or__(CvArr src)\n"
"IplImage___or__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___ior__", _wrap_IplImage___ior__, METH_VARARGS, (char *)"\n"
"__ior__(CvArr src)\n"
"IplImage___ior__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___and__", _wrap_IplImage___and__, METH_VARARGS, (char *)"\n"
"__and__(CvArr src)\n"
"IplImage___and__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___iand__", _wrap_IplImage___iand__, METH_VARARGS, (char *)"\n"
"__iand__(CvArr src)\n"
"IplImage___iand__( self, CvScalar val)\n"
""},
{ (char *)"IplImage___ge__", _wrap_IplImage___ge__, METH_VARARGS, (char *)"\n"
"__ge__(CvArr src)\n"
"IplImage___ge__( self, double val)\n"
""},
{ (char *)"IplImage___eq__", _wrap_IplImage___eq__, METH_VARARGS, (char *)"\n"
"__eq__(CvArr src)\n"
"IplImage___eq__( self, double val)\n"
""},
{ (char *)"IplImage___le__", _wrap_IplImage___le__, METH_VARARGS, (char *)"\n"
"__le__(CvArr src)\n"
"IplImage___le__( self, double val)\n"
""},
{ (char *)"IplImage___ne__", _wrap_IplImage___ne__, METH_VARARGS, (char *)"\n"
"__ne__(CvArr src)\n"
"IplImage___ne__( self, double val)\n"
""},
{ (char *)"IplImage___lt__", _wrap_IplImage___lt__, METH_VARARGS, (char *)"\n"
"__lt__(CvArr src)\n"
"IplImage___lt__( self, double val)\n"
""},
{ (char *)"IplImage___gt__", _wrap_IplImage___gt__, METH_VARARGS, (char *)"\n"
"__gt__(CvArr src)\n"
"IplImage___gt__( self, double val)\n"
""},
{ (char *)"IplImage___mul__", _wrap_IplImage___mul__, METH_VARARGS, (char *)"\n"
"__mul__(CvArr src)\n"
"IplImage___mul__( self, double val)\n"
""},
{ (char *)"IplImage___imul__", _wrap_IplImage___imul__, METH_VARARGS, (char *)"\n"
"__imul__(CvArr src)\n"
"IplImage___imul__( self, double val)\n"
""},
{ (char *)"IplImage___div__", _wrap_IplImage___div__, METH_VARARGS, (char *)"\n"
"__div__(CvArr src)\n"
"IplImage___div__( self, double val)\n"
""},
{ (char *)"IplImage___idiv__", _wrap_IplImage___idiv__, METH_VARARGS, (char *)"\n"
"__idiv__(CvArr src)\n"
"IplImage___idiv__( self, double val)\n"
""},
{ (char *)"IplImage___rdiv__", _wrap_IplImage___rdiv__, METH_VARARGS, (char *)"IplImage___rdiv__( self, CvArr arg)"},
{ (char *)"IplImage___radd__", _wrap_IplImage___radd__, METH_VARARGS, (char *)"\n"
"__radd__(CvArr arg)\n"
"__radd__(CvScalar arg)\n"
"IplImage___radd__( self, double arg)\n"
""},
{ (char *)"IplImage___rsub__", _wrap_IplImage___rsub__, METH_VARARGS, (char *)"\n"
"__rsub__(CvArr arg)\n"
"__rsub__(CvScalar arg)\n"
"IplImage___rsub__( self, double arg)\n"
""},
{ (char *)"IplImage___rmul__", _wrap_IplImage___rmul__, METH_VARARGS, (char *)"\n"
"__rmul__(CvArr arg)\n"
"IplImage___rmul__( self, double arg)\n"
""},
{ (char *)"IplImage___ror__", _wrap_IplImage___ror__, METH_VARARGS, (char *)"\n"
"__ror__(CvScalar arg)\n"
"IplImage___ror__( self, double arg)\n"
""},
{ (char *)"IplImage___rand__", _wrap_IplImage___rand__, METH_VARARGS, (char *)"\n"
"__rand__(CvScalar arg)\n"
"IplImage___rand__( self, double arg)\n"
""},
{ (char *)"IplImage___rxor__", _wrap_IplImage___rxor__, METH_VARARGS, (char *)"\n"
"__rxor__(CvScalar arg)\n"
"IplImage___rxor__( self, double arg)\n"
""},
{ (char *)"IplImage___req__", _wrap_IplImage___req__, METH_VARARGS, (char *)"IplImage___req__( self, double arg)"},
{ (char *)"IplImage___rgt__", _wrap_IplImage___rgt__, METH_VARARGS, (char *)"IplImage___rgt__( self, double arg)"},
{ (char *)"IplImage___rge__", _wrap_IplImage___rge__, METH_VARARGS, (char *)"IplImage___rge__( self, double arg)"},
{ (char *)"IplImage___rlt__", _wrap_IplImage___rlt__, METH_VARARGS, (char *)"IplImage___rlt__( self, double arg)"},
{ (char *)"IplImage___rle__", _wrap_IplImage___rle__, METH_VARARGS, (char *)"IplImage___rle__( self, double arg)"},
{ (char *)"IplImage___rne__", _wrap_IplImage___rne__, METH_VARARGS, (char *)"IplImage___rne__( self, double arg)"},
{ (char *)"IplImage___pow__", _wrap_IplImage___pow__, METH_VARARGS, (char *)"IplImage___pow__( self, double arg)"},
{ (char *)"IplImage___str__", _wrap_IplImage___str__, METH_VARARGS, (char *)"IplImage___str__( self) -> char"},
{ (char *)"IplImage___setitem__", _wrap_IplImage___setitem__, METH_VARARGS, (char *)"\n"
"__setitem__(PyObject object, double val)\n"
"__setitem__(PyObject object, CvPoint val)\n"
"__setitem__(PyObject object, CvPoint2D32f val)\n"
"__setitem__(PyObject object, CvScalar val)\n"
"IplImage___setitem__( self, PyObject object, CvArr arr)\n"
""},
{ (char *)"IplImage___getitem__", _wrap_IplImage___getitem__, METH_VARARGS, (char *)"IplImage___getitem__( self, PyObject object) -> PyObject"},
{ (char *)"IplImage_swigregister", IplImage_swigregister, METH_VARARGS, NULL},
{ (char *)"IplROI_coi_set", _wrap_IplROI_coi_set, METH_VARARGS, (char *)"IplROI_coi_set( self, int coi)"},
{ (char *)"IplROI_coi_get", _wrap_IplROI_coi_get, METH_VARARGS, (char *)"IplROI_coi_get( self) -> int"},
{ (char *)"IplROI_xOffset_set", _wrap_IplROI_xOffset_set, METH_VARARGS, (char *)"IplROI_xOffset_set( self, int xOffset)"},
{ (char *)"IplROI_xOffset_get", _wrap_IplROI_xOffset_get, METH_VARARGS, (char *)"IplROI_xOffset_get( self) -> int"},
{ (char *)"IplROI_yOffset_set", _wrap_IplROI_yOffset_set, METH_VARARGS, (char *)"IplROI_yOffset_set( self, int yOffset)"},
{ (char *)"IplROI_yOffset_get", _wrap_IplROI_yOffset_get, METH_VARARGS, (char *)"IplROI_yOffset_get( self) -> int"},
{ (char *)"IplROI_width_set", _wrap_IplROI_width_set, METH_VARARGS, (char *)"IplROI_width_set( self, int width)"},
{ (char *)"IplROI_width_get", _wrap_IplROI_width_get, METH_VARARGS, (char *)"IplROI_width_get( self) -> int"},
{ (char *)"IplROI_height_set", _wrap_IplROI_height_set, METH_VARARGS, (char *)"IplROI_height_set( self, int height)"},
{ (char *)"IplROI_height_get", _wrap_IplROI_height_get, METH_VARARGS, (char *)"IplROI_height_get( self) -> int"},
{ (char *)"new_IplROI", _wrap_new_IplROI, METH_VARARGS, (char *)"new_IplROI()"},
{ (char *)"delete_IplROI", _wrap_delete_IplROI, METH_VARARGS, (char *)"delete_IplROI( self)"},
{ (char *)"IplROI_swigregister", IplROI_swigregister, METH_VARARGS, NULL},
{ (char *)"IplConvKernel_nCols_set", _wrap_IplConvKernel_nCols_set, METH_VARARGS, (char *)"IplConvKernel_nCols_set( self, int nCols)"},
{ (char *)"IplConvKernel_nCols_get", _wrap_IplConvKernel_nCols_get, METH_VARARGS, (char *)"IplConvKernel_nCols_get( self) -> int"},
{ (char *)"IplConvKernel_nRows_set", _wrap_IplConvKernel_nRows_set, METH_VARARGS, (char *)"IplConvKernel_nRows_set( self, int nRows)"},
{ (char *)"IplConvKernel_nRows_get", _wrap_IplConvKernel_nRows_get, METH_VARARGS, (char *)"IplConvKernel_nRows_get( self) -> int"},
{ (char *)"IplConvKernel_anchorX_set", _wrap_IplConvKernel_anchorX_set, METH_VARARGS, (char *)"IplConvKernel_anchorX_set( self, int anchorX)"},
{ (char *)"IplConvKernel_anchorX_get", _wrap_IplConvKernel_anchorX_get, METH_VARARGS, (char *)"IplConvKernel_anchorX_get( self) -> int"},
{ (char *)"IplConvKernel_anchorY_set", _wrap_IplConvKernel_anchorY_set, METH_VARARGS, (char *)"IplConvKernel_anchorY_set( self, int anchorY)"},
{ (char *)"IplConvKernel_anchorY_get", _wrap_IplConvKernel_anchorY_get, METH_VARARGS, (char *)"IplConvKernel_anchorY_get( self) -> int"},
{ (char *)"IplConvKernel_values_set", _wrap_IplConvKernel_values_set, METH_VARARGS, (char *)"IplConvKernel_values_set( self, int values)"},
{ (char *)"IplConvKernel_values_get", _wrap_IplConvKernel_values_get, METH_VARARGS, (char *)"IplConvKernel_values_get( self) -> int"},
{ (char *)"IplConvKernel_nShiftR_set", _wrap_IplConvKernel_nShiftR_set, METH_VARARGS, (char *)"IplConvKernel_nShiftR_set( self, int nShiftR)"},
{ (char *)"IplConvKernel_nShiftR_get", _wrap_IplConvKernel_nShiftR_get, METH_VARARGS, (char *)"IplConvKernel_nShiftR_get( self) -> int"},
{ (char *)"delete_IplConvKernel", _wrap_delete_IplConvKernel, METH_VARARGS, (char *)"delete_IplConvKernel( self)"},
{ (char *)"IplConvKernel_swigregister", IplConvKernel_swigregister, METH_VARARGS, NULL},
{ (char *)"IplConvKernelFP_nCols_set", _wrap_IplConvKernelFP_nCols_set, METH_VARARGS, (char *)"IplConvKernelFP_nCols_set( self, int nCols)"},
{ (char *)"IplConvKernelFP_nCols_get", _wrap_IplConvKernelFP_nCols_get, METH_VARARGS, (char *)"IplConvKernelFP_nCols_get( self) -> int"},
{ (char *)"IplConvKernelFP_nRows_set", _wrap_IplConvKernelFP_nRows_set, METH_VARARGS, (char *)"IplConvKernelFP_nRows_set( self, int nRows)"},
{ (char *)"IplConvKernelFP_nRows_get", _wrap_IplConvKernelFP_nRows_get, METH_VARARGS, (char *)"IplConvKernelFP_nRows_get( self) -> int"},
{ (char *)"IplConvKernelFP_anchorX_set", _wrap_IplConvKernelFP_anchorX_set, METH_VARARGS, (char *)"IplConvKernelFP_anchorX_set( self, int anchorX)"},
{ (char *)"IplConvKernelFP_anchorX_get", _wrap_IplConvKernelFP_anchorX_get, METH_VARARGS, (char *)"IplConvKernelFP_anchorX_get( self) -> int"},
{ (char *)"IplConvKernelFP_anchorY_set", _wrap_IplConvKernelFP_anchorY_set, METH_VARARGS, (char *)"IplConvKernelFP_anchorY_set( self, int anchorY)"},
{ (char *)"IplConvKernelFP_anchorY_get", _wrap_IplConvKernelFP_anchorY_get, METH_VARARGS, (char *)"IplConvKernelFP_anchorY_get( self) -> int"},
{ (char *)"IplConvKernelFP_values_set", _wrap_IplConvKernelFP_values_set, METH_VARARGS, (char *)"IplConvKernelFP_values_set( self, float values)"},
{ (char *)"IplConvKernelFP_values_get", _wrap_IplConvKernelFP_values_get, METH_VARARGS, (char *)"IplConvKernelFP_values_get( self) -> float"},
{ (char *)"new_IplConvKernelFP", _wrap_new_IplConvKernelFP, METH_VARARGS, (char *)"new_IplConvKernelFP()"},
{ (char *)"delete_IplConvKernelFP", _wrap_delete_IplConvKernelFP, METH_VARARGS, (char *)"delete_IplConvKernelFP( self)"},
{ (char *)"IplConvKernelFP_swigregister", IplConvKernelFP_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMat_type_set", _wrap_CvMat_type_set, METH_VARARGS, (char *)"CvMat_type_set(CvMat self, int type)"},
{ (char *)"CvMat_type_get", _wrap_CvMat_type_get, METH_VARARGS, (char *)"CvMat_type_get(CvMat self) -> int"},
{ (char *)"CvMat_step_set", _wrap_CvMat_step_set, METH_VARARGS, (char *)"CvMat_step_set(CvMat self, int step)"},
{ (char *)"CvMat_step_get", _wrap_CvMat_step_get, METH_VARARGS, (char *)"CvMat_step_get(CvMat self) -> int"},
{ (char *)"CvMat_refcount_set", _wrap_CvMat_refcount_set, METH_VARARGS, (char *)"CvMat_refcount_set(CvMat self, int refcount)"},
{ (char *)"CvMat_refcount_get", _wrap_CvMat_refcount_get, METH_VARARGS, (char *)"CvMat_refcount_get(CvMat self) -> int"},
{ (char *)"CvMat_hdr_refcount_set", _wrap_CvMat_hdr_refcount_set, METH_VARARGS, (char *)"CvMat_hdr_refcount_set(CvMat self, int hdr_refcount)"},
{ (char *)"CvMat_hdr_refcount_get", _wrap_CvMat_hdr_refcount_get, METH_VARARGS, (char *)"CvMat_hdr_refcount_get(CvMat self) -> int"},
{ (char *)"CvMat_data_get", _wrap_CvMat_data_get, METH_VARARGS, (char *)"CvMat_data_get(CvMat self) -> CvMat_data"},
{ (char *)"delete_CvMat", _wrap_delete_CvMat, METH_VARARGS, (char *)"delete_CvMat(CvMat self)"},
{ (char *)"CvMat_depth_get", _wrap_CvMat_depth_get, METH_VARARGS, (char *)"CvMat_depth_get(CvMat self) -> int"},
{ (char *)"CvMat_nChannels_get", _wrap_CvMat_nChannels_get, METH_VARARGS, (char *)"CvMat_nChannels_get(CvMat self) -> int"},
{ (char *)"CvMat_dataOrder_get", _wrap_CvMat_dataOrder_get, METH_VARARGS, (char *)"CvMat_dataOrder_get(CvMat self) -> int"},
{ (char *)"CvMat_origin_get", _wrap_CvMat_origin_get, METH_VARARGS, (char *)"CvMat_origin_get(CvMat self) -> int"},
{ (char *)"CvMat_width_get", _wrap_CvMat_width_get, METH_VARARGS, (char *)"CvMat_width_get(CvMat self) -> int"},
{ (char *)"CvMat_height_get", _wrap_CvMat_height_get, METH_VARARGS, (char *)"CvMat_height_get(CvMat self) -> int"},
{ (char *)"CvMat_imageSize_get", _wrap_CvMat_imageSize_get, METH_VARARGS, (char *)"CvMat_imageSize_get(CvMat self) -> int"},
{ (char *)"CvMat_widthStep_get", _wrap_CvMat_widthStep_get, METH_VARARGS, (char *)"CvMat_widthStep_get(CvMat self) -> int"},
{ (char *)"CvMat_rows_get", _wrap_CvMat_rows_get, METH_VARARGS, (char *)"CvMat_rows_get(CvMat self) -> int"},
{ (char *)"CvMat_cols_get", _wrap_CvMat_cols_get, METH_VARARGS, (char *)"CvMat_cols_get(CvMat self) -> int"},
{ (char *)"CvMat___add__", _wrap_CvMat___add__, METH_VARARGS, (char *)"\n"
"__add__(CvArr src) -> CvMat\n"
"CvMat___add__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___iadd__", _wrap_CvMat___iadd__, METH_VARARGS, (char *)"\n"
"__iadd__(CvArr src) -> CvMat\n"
"CvMat___iadd__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___xor__", _wrap_CvMat___xor__, METH_VARARGS, (char *)"\n"
"__xor__(CvArr src) -> CvMat\n"
"CvMat___xor__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___ixor__", _wrap_CvMat___ixor__, METH_VARARGS, (char *)"\n"
"__ixor__(CvArr src) -> CvMat\n"
"CvMat___ixor__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___sub__", _wrap_CvMat___sub__, METH_VARARGS, (char *)"\n"
"__sub__(CvArr src) -> CvMat\n"
"CvMat___sub__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___isub__", _wrap_CvMat___isub__, METH_VARARGS, (char *)"\n"
"__isub__(CvArr src) -> CvMat\n"
"CvMat___isub__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___or__", _wrap_CvMat___or__, METH_VARARGS, (char *)"\n"
"__or__(CvArr src) -> CvMat\n"
"CvMat___or__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___ior__", _wrap_CvMat___ior__, METH_VARARGS, (char *)"\n"
"__ior__(CvArr src) -> CvMat\n"
"CvMat___ior__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___and__", _wrap_CvMat___and__, METH_VARARGS, (char *)"\n"
"__and__(CvArr src) -> CvMat\n"
"CvMat___and__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___iand__", _wrap_CvMat___iand__, METH_VARARGS, (char *)"\n"
"__iand__(CvArr src) -> CvMat\n"
"CvMat___iand__(CvMat self, CvScalar val) -> CvMat\n"
""},
{ (char *)"CvMat___ge__", _wrap_CvMat___ge__, METH_VARARGS, (char *)"\n"
"__ge__(CvArr src) -> CvMat\n"
"CvMat___ge__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___eq__", _wrap_CvMat___eq__, METH_VARARGS, (char *)"\n"
"__eq__(CvArr src) -> CvMat\n"
"CvMat___eq__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___le__", _wrap_CvMat___le__, METH_VARARGS, (char *)"\n"
"__le__(CvArr src) -> CvMat\n"
"CvMat___le__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___ne__", _wrap_CvMat___ne__, METH_VARARGS, (char *)"\n"
"__ne__(CvArr src) -> CvMat\n"
"CvMat___ne__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___lt__", _wrap_CvMat___lt__, METH_VARARGS, (char *)"\n"
"__lt__(CvArr src) -> CvMat\n"
"CvMat___lt__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___gt__", _wrap_CvMat___gt__, METH_VARARGS, (char *)"\n"
"__gt__(CvArr src) -> CvMat\n"
"CvMat___gt__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___mul__", _wrap_CvMat___mul__, METH_VARARGS, (char *)"\n"
"__mul__(CvArr src) -> CvMat\n"
"CvMat___mul__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___imul__", _wrap_CvMat___imul__, METH_VARARGS, (char *)"\n"
"__imul__(CvArr src) -> CvMat\n"
"CvMat___imul__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___div__", _wrap_CvMat___div__, METH_VARARGS, (char *)"\n"
"__div__(CvArr src) -> CvMat\n"
"CvMat___div__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___idiv__", _wrap_CvMat___idiv__, METH_VARARGS, (char *)"\n"
"__idiv__(CvArr src) -> CvMat\n"
"CvMat___idiv__(CvMat self, double val) -> CvMat\n"
""},
{ (char *)"CvMat___radd__", _wrap_CvMat___radd__, METH_VARARGS, (char *)"\n"
"__radd__(CvArr arg) -> CvMat\n"
"__radd__(CvScalar arg) -> CvMat\n"
"CvMat___radd__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___rsub__", _wrap_CvMat___rsub__, METH_VARARGS, (char *)"\n"
"__rsub__(CvArr arg) -> CvMat\n"
"__rsub__(CvScalar arg) -> CvMat\n"
"CvMat___rsub__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___rmul__", _wrap_CvMat___rmul__, METH_VARARGS, (char *)"\n"
"__rmul__(CvArr arg) -> CvMat\n"
"CvMat___rmul__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___ror__", _wrap_CvMat___ror__, METH_VARARGS, (char *)"\n"
"__ror__(CvScalar arg) -> CvMat\n"
"CvMat___ror__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___rand__", _wrap_CvMat___rand__, METH_VARARGS, (char *)"\n"
"__rand__(CvScalar arg) -> CvMat\n"
"CvMat___rand__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___rxor__", _wrap_CvMat___rxor__, METH_VARARGS, (char *)"\n"
"__rxor__(CvScalar arg) -> CvMat\n"
"CvMat___rxor__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___req__", _wrap_CvMat___req__, METH_VARARGS, (char *)"CvMat___req__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rgt__", _wrap_CvMat___rgt__, METH_VARARGS, (char *)"CvMat___rgt__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rge__", _wrap_CvMat___rge__, METH_VARARGS, (char *)"CvMat___rge__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rlt__", _wrap_CvMat___rlt__, METH_VARARGS, (char *)"CvMat___rlt__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rle__", _wrap_CvMat___rle__, METH_VARARGS, (char *)"CvMat___rle__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rne__", _wrap_CvMat___rne__, METH_VARARGS, (char *)"CvMat___rne__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___rdiv__", _wrap_CvMat___rdiv__, METH_VARARGS, (char *)"\n"
"__rdiv__(CvArr arg) -> CvMat\n"
"CvMat___rdiv__(CvMat self, double arg) -> CvMat\n"
""},
{ (char *)"CvMat___pow__", _wrap_CvMat___pow__, METH_VARARGS, (char *)"CvMat___pow__(CvMat self, double arg) -> CvMat"},
{ (char *)"CvMat___str__", _wrap_CvMat___str__, METH_VARARGS, (char *)"CvMat___str__(CvMat self) -> char"},
{ (char *)"CvMat___setitem__", _wrap_CvMat___setitem__, METH_VARARGS, (char *)"\n"
"__setitem__(PyObject object, double val)\n"
"__setitem__(PyObject object, CvPoint val)\n"
"__setitem__(PyObject object, CvPoint2D32f val)\n"
"__setitem__(PyObject object, CvScalar val)\n"
"CvMat___setitem__(CvMat self, PyObject object, CvArr arr)\n"
""},
{ (char *)"CvMat___getitem__", _wrap_CvMat___getitem__, METH_VARARGS, (char *)"CvMat___getitem__(CvMat self, PyObject object) -> PyObject"},
{ (char *)"CvMat___invert__", _wrap_CvMat___invert__, METH_VARARGS, (char *)"CvMat___invert__(CvMat self) -> CvMat"},
{ (char *)"CvMat_imageData_set", _wrap_CvMat_imageData_set, METH_VARARGS, (char *)"CvMat_imageData_set(CvMat self, PyObject imageData)"},
{ (char *)"CvMat_imageData_get", _wrap_CvMat_imageData_get, METH_VARARGS, (char *)"CvMat_imageData_get(CvMat self) -> PyObject"},
{ (char *)"CvMat_swigregister", CvMat_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMat_data_ptr_set", _wrap_CvMat_data_ptr_set, METH_VARARGS, (char *)"CvMat_data_ptr_set(CvMat_data self, uchar ptr)"},
{ (char *)"CvMat_data_ptr_get", _wrap_CvMat_data_ptr_get, METH_VARARGS, (char *)"CvMat_data_ptr_get(CvMat_data self) -> uchar"},
{ (char *)"CvMat_data_s_set", _wrap_CvMat_data_s_set, METH_VARARGS, (char *)"CvMat_data_s_set(CvMat_data self, short s)"},
{ (char *)"CvMat_data_s_get", _wrap_CvMat_data_s_get, METH_VARARGS, (char *)"CvMat_data_s_get(CvMat_data self) -> short"},
{ (char *)"CvMat_data_i_set", _wrap_CvMat_data_i_set, METH_VARARGS, (char *)"CvMat_data_i_set(CvMat_data self, int i)"},
{ (char *)"CvMat_data_i_get", _wrap_CvMat_data_i_get, METH_VARARGS, (char *)"CvMat_data_i_get(CvMat_data self) -> int"},
{ (char *)"CvMat_data_fl_set", _wrap_CvMat_data_fl_set, METH_VARARGS, (char *)"CvMat_data_fl_set(CvMat_data self, float fl)"},
{ (char *)"CvMat_data_fl_get", _wrap_CvMat_data_fl_get, METH_VARARGS, (char *)"CvMat_data_fl_get(CvMat_data self) -> float"},
{ (char *)"CvMat_data_db_set", _wrap_CvMat_data_db_set, METH_VARARGS, (char *)"CvMat_data_db_set(CvMat_data self, double db)"},
{ (char *)"CvMat_data_db_get", _wrap_CvMat_data_db_get, METH_VARARGS, (char *)"CvMat_data_db_get(CvMat_data self) -> double"},
{ (char *)"new_CvMat_data", _wrap_new_CvMat_data, METH_VARARGS, (char *)"new_CvMat_data() -> CvMat_data"},
{ (char *)"delete_CvMat_data", _wrap_delete_CvMat_data, METH_VARARGS, (char *)"delete_CvMat_data(CvMat_data self)"},
{ (char *)"CvMat_data_swigregister", CvMat_data_swigregister, METH_VARARGS, NULL},
{ (char *)"cvMat", _wrap_cvMat, METH_VARARGS, (char *)"\n"
"cvMat(int rows, int cols, int type, void data=None) -> CvMat\n"
"cvMat(int rows, int cols, int type) -> CvMat\n"
""},
{ (char *)"cvmGet", _wrap_cvmGet, METH_VARARGS, (char *)"cvmGet(CvMat mat, int row, int col) -> double"},
{ (char *)"cvmSet", _wrap_cvmSet, METH_VARARGS, (char *)"cvmSet(CvMat mat, int row, int col, double value)"},
{ (char *)"cvCvToIplDepth", _wrap_cvCvToIplDepth, METH_VARARGS, (char *)"cvCvToIplDepth(int type) -> int"},
{ (char *)"CvMatND_type_set", _wrap_CvMatND_type_set, METH_VARARGS, (char *)"CvMatND_type_set(CvMatND self, int type)"},
{ (char *)"CvMatND_type_get", _wrap_CvMatND_type_get, METH_VARARGS, (char *)"CvMatND_type_get(CvMatND self) -> int"},
{ (char *)"CvMatND_dims_set", _wrap_CvMatND_dims_set, METH_VARARGS, (char *)"CvMatND_dims_set(CvMatND self, int dims)"},
{ (char *)"CvMatND_dims_get", _wrap_CvMatND_dims_get, METH_VARARGS, (char *)"CvMatND_dims_get(CvMatND self) -> int"},
{ (char *)"CvMatND_refcount_set", _wrap_CvMatND_refcount_set, METH_VARARGS, (char *)"CvMatND_refcount_set(CvMatND self, int refcount)"},
{ (char *)"CvMatND_refcount_get", _wrap_CvMatND_refcount_get, METH_VARARGS, (char *)"CvMatND_refcount_get(CvMatND self) -> int"},
{ (char *)"CvMatND_hdr_refcount_set", _wrap_CvMatND_hdr_refcount_set, METH_VARARGS, (char *)"CvMatND_hdr_refcount_set(CvMatND self, int hdr_refcount)"},
{ (char *)"CvMatND_hdr_refcount_get", _wrap_CvMatND_hdr_refcount_get, METH_VARARGS, (char *)"CvMatND_hdr_refcount_get(CvMatND self) -> int"},
{ (char *)"CvMatND_dim_get", _wrap_CvMatND_dim_get, METH_VARARGS, (char *)"CvMatND_dim_get(CvMatND self) -> CvMatND_dim"},
{ (char *)"CvMatND_data_get", _wrap_CvMatND_data_get, METH_VARARGS, (char *)"CvMatND_data_get(CvMatND self) -> CvMatND_data"},
{ (char *)"delete_CvMatND", _wrap_delete_CvMatND, METH_VARARGS, (char *)"delete_CvMatND(CvMatND self)"},
{ (char *)"CvMatND_swigregister", CvMatND_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMatND_dim_size_set", _wrap_CvMatND_dim_size_set, METH_VARARGS, (char *)"CvMatND_dim_size_set(CvMatND_dim self, int size)"},
{ (char *)"CvMatND_dim_size_get", _wrap_CvMatND_dim_size_get, METH_VARARGS, (char *)"CvMatND_dim_size_get(CvMatND_dim self) -> int"},
{ (char *)"CvMatND_dim_step_set", _wrap_CvMatND_dim_step_set, METH_VARARGS, (char *)"CvMatND_dim_step_set(CvMatND_dim self, int step)"},
{ (char *)"CvMatND_dim_step_get", _wrap_CvMatND_dim_step_get, METH_VARARGS, (char *)"CvMatND_dim_step_get(CvMatND_dim self) -> int"},
{ (char *)"new_CvMatND_dim", _wrap_new_CvMatND_dim, METH_VARARGS, (char *)"new_CvMatND_dim() -> CvMatND_dim"},
{ (char *)"delete_CvMatND_dim", _wrap_delete_CvMatND_dim, METH_VARARGS, (char *)"delete_CvMatND_dim(CvMatND_dim self)"},
{ (char *)"CvMatND_dim_swigregister", CvMatND_dim_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMatND_data_ptr_set", _wrap_CvMatND_data_ptr_set, METH_VARARGS, (char *)"CvMatND_data_ptr_set(CvMatND_data self, uchar ptr)"},
{ (char *)"CvMatND_data_ptr_get", _wrap_CvMatND_data_ptr_get, METH_VARARGS, (char *)"CvMatND_data_ptr_get(CvMatND_data self) -> uchar"},
{ (char *)"CvMatND_data_fl_set", _wrap_CvMatND_data_fl_set, METH_VARARGS, (char *)"CvMatND_data_fl_set(CvMatND_data self, float fl)"},
{ (char *)"CvMatND_data_fl_get", _wrap_CvMatND_data_fl_get, METH_VARARGS, (char *)"CvMatND_data_fl_get(CvMatND_data self) -> float"},
{ (char *)"CvMatND_data_db_set", _wrap_CvMatND_data_db_set, METH_VARARGS, (char *)"CvMatND_data_db_set(CvMatND_data self, double db)"},
{ (char *)"CvMatND_data_db_get", _wrap_CvMatND_data_db_get, METH_VARARGS, (char *)"CvMatND_data_db_get(CvMatND_data self) -> double"},
{ (char *)"CvMatND_data_i_set", _wrap_CvMatND_data_i_set, METH_VARARGS, (char *)"CvMatND_data_i_set(CvMatND_data self, int i)"},
{ (char *)"CvMatND_data_i_get", _wrap_CvMatND_data_i_get, METH_VARARGS, (char *)"CvMatND_data_i_get(CvMatND_data self) -> int"},
{ (char *)"CvMatND_data_s_set", _wrap_CvMatND_data_s_set, METH_VARARGS, (char *)"CvMatND_data_s_set(CvMatND_data self, short s)"},
{ (char *)"CvMatND_data_s_get", _wrap_CvMatND_data_s_get, METH_VARARGS, (char *)"CvMatND_data_s_get(CvMatND_data self) -> short"},
{ (char *)"new_CvMatND_data", _wrap_new_CvMatND_data, METH_VARARGS, (char *)"new_CvMatND_data() -> CvMatND_data"},
{ (char *)"delete_CvMatND_data", _wrap_delete_CvMatND_data, METH_VARARGS, (char *)"delete_CvMatND_data(CvMatND_data self)"},
{ (char *)"CvMatND_data_swigregister", CvMatND_data_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSparseMat_type_set", _wrap_CvSparseMat_type_set, METH_VARARGS, (char *)"CvSparseMat_type_set(CvSparseMat self, int type)"},
{ (char *)"CvSparseMat_type_get", _wrap_CvSparseMat_type_get, METH_VARARGS, (char *)"CvSparseMat_type_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_dims_set", _wrap_CvSparseMat_dims_set, METH_VARARGS, (char *)"CvSparseMat_dims_set(CvSparseMat self, int dims)"},
{ (char *)"CvSparseMat_dims_get", _wrap_CvSparseMat_dims_get, METH_VARARGS, (char *)"CvSparseMat_dims_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_refcount_set", _wrap_CvSparseMat_refcount_set, METH_VARARGS, (char *)"CvSparseMat_refcount_set(CvSparseMat self, int refcount)"},
{ (char *)"CvSparseMat_refcount_get", _wrap_CvSparseMat_refcount_get, METH_VARARGS, (char *)"CvSparseMat_refcount_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_hdr_refcount_set", _wrap_CvSparseMat_hdr_refcount_set, METH_VARARGS, (char *)"CvSparseMat_hdr_refcount_set(CvSparseMat self, int hdr_refcount)"},
{ (char *)"CvSparseMat_hdr_refcount_get", _wrap_CvSparseMat_hdr_refcount_get, METH_VARARGS, (char *)"CvSparseMat_hdr_refcount_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_heap_set", _wrap_CvSparseMat_heap_set, METH_VARARGS, (char *)"CvSparseMat_heap_set(CvSparseMat self, CvSet heap)"},
{ (char *)"CvSparseMat_heap_get", _wrap_CvSparseMat_heap_get, METH_VARARGS, (char *)"CvSparseMat_heap_get(CvSparseMat self) -> CvSet"},
{ (char *)"CvSparseMat_hashtable_set", _wrap_CvSparseMat_hashtable_set, METH_VARARGS, (char *)"CvSparseMat_hashtable_set(CvSparseMat self, void hashtable)"},
{ (char *)"CvSparseMat_hashtable_get", _wrap_CvSparseMat_hashtable_get, METH_VARARGS, (char *)"CvSparseMat_hashtable_get(CvSparseMat self) -> void"},
{ (char *)"CvSparseMat_hashsize_set", _wrap_CvSparseMat_hashsize_set, METH_VARARGS, (char *)"CvSparseMat_hashsize_set(CvSparseMat self, int hashsize)"},
{ (char *)"CvSparseMat_hashsize_get", _wrap_CvSparseMat_hashsize_get, METH_VARARGS, (char *)"CvSparseMat_hashsize_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_valoffset_set", _wrap_CvSparseMat_valoffset_set, METH_VARARGS, (char *)"CvSparseMat_valoffset_set(CvSparseMat self, int valoffset)"},
{ (char *)"CvSparseMat_valoffset_get", _wrap_CvSparseMat_valoffset_get, METH_VARARGS, (char *)"CvSparseMat_valoffset_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_idxoffset_set", _wrap_CvSparseMat_idxoffset_set, METH_VARARGS, (char *)"CvSparseMat_idxoffset_set(CvSparseMat self, int idxoffset)"},
{ (char *)"CvSparseMat_idxoffset_get", _wrap_CvSparseMat_idxoffset_get, METH_VARARGS, (char *)"CvSparseMat_idxoffset_get(CvSparseMat self) -> int"},
{ (char *)"CvSparseMat_size_set", _wrap_CvSparseMat_size_set, METH_VARARGS, (char *)"CvSparseMat_size_set(CvSparseMat self, int size)"},
{ (char *)"CvSparseMat_size_get", _wrap_CvSparseMat_size_get, METH_VARARGS, (char *)"CvSparseMat_size_get(CvSparseMat self) -> int"},
{ (char *)"delete_CvSparseMat", _wrap_delete_CvSparseMat, METH_VARARGS, (char *)"delete_CvSparseMat(CvSparseMat self)"},
{ (char *)"CvSparseMat_swigregister", CvSparseMat_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSparseNode_hashval_set", _wrap_CvSparseNode_hashval_set, METH_VARARGS, (char *)"CvSparseNode_hashval_set(CvSparseNode self, unsigned int hashval)"},
{ (char *)"CvSparseNode_hashval_get", _wrap_CvSparseNode_hashval_get, METH_VARARGS, (char *)"CvSparseNode_hashval_get(CvSparseNode self) -> unsigned int"},
{ (char *)"CvSparseNode_next_set", _wrap_CvSparseNode_next_set, METH_VARARGS, (char *)"CvSparseNode_next_set(CvSparseNode self, CvSparseNode next)"},
{ (char *)"CvSparseNode_next_get", _wrap_CvSparseNode_next_get, METH_VARARGS, (char *)"CvSparseNode_next_get(CvSparseNode self) -> CvSparseNode"},
{ (char *)"new_CvSparseNode", _wrap_new_CvSparseNode, METH_VARARGS, (char *)"new_CvSparseNode() -> CvSparseNode"},
{ (char *)"delete_CvSparseNode", _wrap_delete_CvSparseNode, METH_VARARGS, (char *)"delete_CvSparseNode(CvSparseNode self)"},
{ (char *)"CvSparseNode_swigregister", CvSparseNode_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSparseMatIterator_mat_set", _wrap_CvSparseMatIterator_mat_set, METH_VARARGS, (char *)"CvSparseMatIterator_mat_set(CvSparseMatIterator self, CvSparseMat mat)"},
{ (char *)"CvSparseMatIterator_mat_get", _wrap_CvSparseMatIterator_mat_get, METH_VARARGS, (char *)"CvSparseMatIterator_mat_get(CvSparseMatIterator self) -> CvSparseMat"},
{ (char *)"CvSparseMatIterator_node_set", _wrap_CvSparseMatIterator_node_set, METH_VARARGS, (char *)"CvSparseMatIterator_node_set(CvSparseMatIterator self, CvSparseNode node)"},
{ (char *)"CvSparseMatIterator_node_get", _wrap_CvSparseMatIterator_node_get, METH_VARARGS, (char *)"CvSparseMatIterator_node_get(CvSparseMatIterator self) -> CvSparseNode"},
{ (char *)"CvSparseMatIterator_curidx_set", _wrap_CvSparseMatIterator_curidx_set, METH_VARARGS, (char *)"CvSparseMatIterator_curidx_set(CvSparseMatIterator self, int curidx)"},
{ (char *)"CvSparseMatIterator_curidx_get", _wrap_CvSparseMatIterator_curidx_get, METH_VARARGS, (char *)"CvSparseMatIterator_curidx_get(CvSparseMatIterator self) -> int"},
{ (char *)"new_CvSparseMatIterator", _wrap_new_CvSparseMatIterator, METH_VARARGS, (char *)"new_CvSparseMatIterator() -> CvSparseMatIterator"},
{ (char *)"delete_CvSparseMatIterator", _wrap_delete_CvSparseMatIterator, METH_VARARGS, (char *)"delete_CvSparseMatIterator(CvSparseMatIterator self)"},
{ (char *)"CvSparseMatIterator_swigregister", CvSparseMatIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHistogram_type_set", _wrap_CvHistogram_type_set, METH_VARARGS, (char *)"CvHistogram_type_set(CvHistogram self, int type)"},
{ (char *)"CvHistogram_type_get", _wrap_CvHistogram_type_get, METH_VARARGS, (char *)"CvHistogram_type_get(CvHistogram self) -> int"},
{ (char *)"CvHistogram_bins_set", _wrap_CvHistogram_bins_set, METH_VARARGS, (char *)"CvHistogram_bins_set(CvHistogram self, CvArr bins)"},
{ (char *)"CvHistogram_bins_get", _wrap_CvHistogram_bins_get, METH_VARARGS, (char *)"CvHistogram_bins_get(CvHistogram self) -> CvArr"},
{ (char *)"CvHistogram_thresh_set", _wrap_CvHistogram_thresh_set, METH_VARARGS, (char *)"CvHistogram_thresh_set(CvHistogram self, float thresh)"},
{ (char *)"CvHistogram_thresh_get", _wrap_CvHistogram_thresh_get, METH_VARARGS, (char *)"CvHistogram_thresh_get(CvHistogram self) -> float"},
{ (char *)"CvHistogram_thresh2_set", _wrap_CvHistogram_thresh2_set, METH_VARARGS, (char *)"CvHistogram_thresh2_set(CvHistogram self, float thresh2)"},
{ (char *)"CvHistogram_thresh2_get", _wrap_CvHistogram_thresh2_get, METH_VARARGS, (char *)"CvHistogram_thresh2_get(CvHistogram self) -> float"},
{ (char *)"CvHistogram_mat_set", _wrap_CvHistogram_mat_set, METH_VARARGS, (char *)"CvHistogram_mat_set(CvHistogram self, CvMatND mat)"},
{ (char *)"CvHistogram_mat_get", _wrap_CvHistogram_mat_get, METH_VARARGS, (char *)"CvHistogram_mat_get(CvHistogram self) -> CvMatND"},
{ (char *)"delete_CvHistogram", _wrap_delete_CvHistogram, METH_VARARGS, (char *)"delete_CvHistogram(CvHistogram self)"},
{ (char *)"CvHistogram_swigregister", CvHistogram_swigregister, METH_VARARGS, NULL},
{ (char *)"CvRect_x_set", _wrap_CvRect_x_set, METH_VARARGS, (char *)"CvRect_x_set(CvRect self, int x)"},
{ (char *)"CvRect_x_get", _wrap_CvRect_x_get, METH_VARARGS, (char *)"CvRect_x_get(CvRect self) -> int"},
{ (char *)"CvRect_y_set", _wrap_CvRect_y_set, METH_VARARGS, (char *)"CvRect_y_set(CvRect self, int y)"},
{ (char *)"CvRect_y_get", _wrap_CvRect_y_get, METH_VARARGS, (char *)"CvRect_y_get(CvRect self) -> int"},
{ (char *)"CvRect_width_set", _wrap_CvRect_width_set, METH_VARARGS, (char *)"CvRect_width_set(CvRect self, int width)"},
{ (char *)"CvRect_width_get", _wrap_CvRect_width_get, METH_VARARGS, (char *)"CvRect_width_get(CvRect self) -> int"},
{ (char *)"CvRect_height_set", _wrap_CvRect_height_set, METH_VARARGS, (char *)"CvRect_height_set(CvRect self, int height)"},
{ (char *)"CvRect_height_get", _wrap_CvRect_height_get, METH_VARARGS, (char *)"CvRect_height_get(CvRect self) -> int"},
{ (char *)"new_CvRect", _wrap_new_CvRect, METH_VARARGS, (char *)"new_CvRect() -> CvRect"},
{ (char *)"delete_CvRect", _wrap_delete_CvRect, METH_VARARGS, (char *)"delete_CvRect(CvRect self)"},
{ (char *)"CvRect_swigregister", CvRect_swigregister, METH_VARARGS, NULL},
{ (char *)"cvRect", _wrap_cvRect, METH_VARARGS, (char *)"cvRect(int x, int y, int width, int height) -> CvRect"},
{ (char *)"cvRectToROI", _wrap_cvRectToROI, METH_VARARGS, (char *)"cvRectToROI(CvRect rect, int coi)"},
{ (char *)"cvROIToRect", _wrap_cvROIToRect, METH_VARARGS, (char *)"cvROIToRect( roi) -> CvRect"},
{ (char *)"CvTermCriteria_type_set", _wrap_CvTermCriteria_type_set, METH_VARARGS, (char *)"CvTermCriteria_type_set(CvTermCriteria self, int type)"},
{ (char *)"CvTermCriteria_type_get", _wrap_CvTermCriteria_type_get, METH_VARARGS, (char *)"CvTermCriteria_type_get(CvTermCriteria self) -> int"},
{ (char *)"CvTermCriteria_max_iter_set", _wrap_CvTermCriteria_max_iter_set, METH_VARARGS, (char *)"CvTermCriteria_max_iter_set(CvTermCriteria self, int max_iter)"},
{ (char *)"CvTermCriteria_max_iter_get", _wrap_CvTermCriteria_max_iter_get, METH_VARARGS, (char *)"CvTermCriteria_max_iter_get(CvTermCriteria self) -> int"},
{ (char *)"CvTermCriteria_epsilon_set", _wrap_CvTermCriteria_epsilon_set, METH_VARARGS, (char *)"CvTermCriteria_epsilon_set(CvTermCriteria self, double epsilon)"},
{ (char *)"CvTermCriteria_epsilon_get", _wrap_CvTermCriteria_epsilon_get, METH_VARARGS, (char *)"CvTermCriteria_epsilon_get(CvTermCriteria self) -> double"},
{ (char *)"new_CvTermCriteria", _wrap_new_CvTermCriteria, METH_VARARGS, (char *)"new_CvTermCriteria() -> CvTermCriteria"},
{ (char *)"delete_CvTermCriteria", _wrap_delete_CvTermCriteria, METH_VARARGS, (char *)"delete_CvTermCriteria(CvTermCriteria self)"},
{ (char *)"CvTermCriteria_swigregister", CvTermCriteria_swigregister, METH_VARARGS, NULL},
{ (char *)"cvTermCriteria", _wrap_cvTermCriteria, METH_VARARGS, (char *)"cvTermCriteria(int type, int max_iter, double epsilon) -> CvTermCriteria"},
{ (char *)"CvPoint_x_set", _wrap_CvPoint_x_set, METH_VARARGS, (char *)"CvPoint_x_set(CvPoint self, int x)"},
{ (char *)"CvPoint_x_get", _wrap_CvPoint_x_get, METH_VARARGS, (char *)"CvPoint_x_get(CvPoint self) -> int"},
{ (char *)"CvPoint_y_set", _wrap_CvPoint_y_set, METH_VARARGS, (char *)"CvPoint_y_set(CvPoint self, int y)"},
{ (char *)"CvPoint_y_get", _wrap_CvPoint_y_get, METH_VARARGS, (char *)"CvPoint_y_get(CvPoint self) -> int"},
{ (char *)"CvPoint___str__", _wrap_CvPoint___str__, METH_VARARGS, (char *)"CvPoint___str__(CvPoint self) -> char"},
{ (char *)"CvPoint___repr__", _wrap_CvPoint___repr__, METH_VARARGS, (char *)"CvPoint___repr__(CvPoint self) -> char"},
{ (char *)"new_CvPoint", _wrap_new_CvPoint, METH_VARARGS, (char *)"new_CvPoint() -> CvPoint"},
{ (char *)"delete_CvPoint", _wrap_delete_CvPoint, METH_VARARGS, (char *)"delete_CvPoint(CvPoint self)"},
{ (char *)"CvPoint_swigregister", CvPoint_swigregister, METH_VARARGS, NULL},
{ (char *)"cvPoint", _wrap_cvPoint, METH_VARARGS, (char *)"cvPoint(int x, int y) -> CvPoint"},
{ (char *)"CvPoint2D32f_x_set", _wrap_CvPoint2D32f_x_set, METH_VARARGS, (char *)"CvPoint2D32f_x_set(CvPoint2D32f self, float x)"},
{ (char *)"CvPoint2D32f_x_get", _wrap_CvPoint2D32f_x_get, METH_VARARGS, (char *)"CvPoint2D32f_x_get(CvPoint2D32f self) -> float"},
{ (char *)"CvPoint2D32f_y_set", _wrap_CvPoint2D32f_y_set, METH_VARARGS, (char *)"CvPoint2D32f_y_set(CvPoint2D32f self, float y)"},
{ (char *)"CvPoint2D32f_y_get", _wrap_CvPoint2D32f_y_get, METH_VARARGS, (char *)"CvPoint2D32f_y_get(CvPoint2D32f self) -> float"},
{ (char *)"CvPoint2D32f___str__", _wrap_CvPoint2D32f___str__, METH_VARARGS, (char *)"CvPoint2D32f___str__(CvPoint2D32f self) -> char"},
{ (char *)"CvPoint2D32f___repr__", _wrap_CvPoint2D32f___repr__, METH_VARARGS, (char *)"CvPoint2D32f___repr__(CvPoint2D32f self) -> char"},
{ (char *)"new_CvPoint2D32f", _wrap_new_CvPoint2D32f, METH_VARARGS, (char *)"new_CvPoint2D32f() -> CvPoint2D32f"},
{ (char *)"delete_CvPoint2D32f", _wrap_delete_CvPoint2D32f, METH_VARARGS, (char *)"delete_CvPoint2D32f(CvPoint2D32f self)"},
{ (char *)"CvPoint2D32f_swigregister", CvPoint2D32f_swigregister, METH_VARARGS, NULL},
{ (char *)"cvPoint2D32f", _wrap_cvPoint2D32f, METH_VARARGS, (char *)"cvPoint2D32f(double x, double y) -> CvPoint2D32f"},
{ (char *)"cvPointTo32f", _wrap_cvPointTo32f, METH_VARARGS, (char *)"cvPointTo32f(CvPoint point) -> CvPoint2D32f"},
{ (char *)"cvPointFrom32f", _wrap_cvPointFrom32f, METH_VARARGS, (char *)"cvPointFrom32f(CvPoint2D32f point) -> CvPoint"},
{ (char *)"CvPoint3D32f_x_set", _wrap_CvPoint3D32f_x_set, METH_VARARGS, (char *)"CvPoint3D32f_x_set(CvPoint3D32f self, float x)"},
{ (char *)"CvPoint3D32f_x_get", _wrap_CvPoint3D32f_x_get, METH_VARARGS, (char *)"CvPoint3D32f_x_get(CvPoint3D32f self) -> float"},
{ (char *)"CvPoint3D32f_y_set", _wrap_CvPoint3D32f_y_set, METH_VARARGS, (char *)"CvPoint3D32f_y_set(CvPoint3D32f self, float y)"},
{ (char *)"CvPoint3D32f_y_get", _wrap_CvPoint3D32f_y_get, METH_VARARGS, (char *)"CvPoint3D32f_y_get(CvPoint3D32f self) -> float"},
{ (char *)"CvPoint3D32f_z_set", _wrap_CvPoint3D32f_z_set, METH_VARARGS, (char *)"CvPoint3D32f_z_set(CvPoint3D32f self, float z)"},
{ (char *)"CvPoint3D32f_z_get", _wrap_CvPoint3D32f_z_get, METH_VARARGS, (char *)"CvPoint3D32f_z_get(CvPoint3D32f self) -> float"},
{ (char *)"new_CvPoint3D32f", _wrap_new_CvPoint3D32f, METH_VARARGS, (char *)"new_CvPoint3D32f() -> CvPoint3D32f"},
{ (char *)"delete_CvPoint3D32f", _wrap_delete_CvPoint3D32f, METH_VARARGS, (char *)"delete_CvPoint3D32f(CvPoint3D32f self)"},
{ (char *)"CvPoint3D32f_swigregister", CvPoint3D32f_swigregister, METH_VARARGS, NULL},
{ (char *)"cvPoint3D32f", _wrap_cvPoint3D32f, METH_VARARGS, (char *)"cvPoint3D32f(double x, double y, double z) -> CvPoint3D32f"},
{ (char *)"CvPoint2D64f_x_set", _wrap_CvPoint2D64f_x_set, METH_VARARGS, (char *)"CvPoint2D64f_x_set(CvPoint2D64f self, double x)"},
{ (char *)"CvPoint2D64f_x_get", _wrap_CvPoint2D64f_x_get, METH_VARARGS, (char *)"CvPoint2D64f_x_get(CvPoint2D64f self) -> double"},
{ (char *)"CvPoint2D64f_y_set", _wrap_CvPoint2D64f_y_set, METH_VARARGS, (char *)"CvPoint2D64f_y_set(CvPoint2D64f self, double y)"},
{ (char *)"CvPoint2D64f_y_get", _wrap_CvPoint2D64f_y_get, METH_VARARGS, (char *)"CvPoint2D64f_y_get(CvPoint2D64f self) -> double"},
{ (char *)"new_CvPoint2D64f", _wrap_new_CvPoint2D64f, METH_VARARGS, (char *)"new_CvPoint2D64f() -> CvPoint2D64f"},
{ (char *)"delete_CvPoint2D64f", _wrap_delete_CvPoint2D64f, METH_VARARGS, (char *)"delete_CvPoint2D64f(CvPoint2D64f self)"},
{ (char *)"CvPoint2D64f_swigregister", CvPoint2D64f_swigregister, METH_VARARGS, NULL},
{ (char *)"cvPoint2D64f", _wrap_cvPoint2D64f, METH_VARARGS, (char *)"cvPoint2D64f(double x, double y) -> CvPoint2D64f"},
{ (char *)"CvPoint3D64f_x_set", _wrap_CvPoint3D64f_x_set, METH_VARARGS, (char *)"CvPoint3D64f_x_set(CvPoint3D64f self, double x)"},
{ (char *)"CvPoint3D64f_x_get", _wrap_CvPoint3D64f_x_get, METH_VARARGS, (char *)"CvPoint3D64f_x_get(CvPoint3D64f self) -> double"},
{ (char *)"CvPoint3D64f_y_set", _wrap_CvPoint3D64f_y_set, METH_VARARGS, (char *)"CvPoint3D64f_y_set(CvPoint3D64f self, double y)"},
{ (char *)"CvPoint3D64f_y_get", _wrap_CvPoint3D64f_y_get, METH_VARARGS, (char *)"CvPoint3D64f_y_get(CvPoint3D64f self) -> double"},
{ (char *)"CvPoint3D64f_z_set", _wrap_CvPoint3D64f_z_set, METH_VARARGS, (char *)"CvPoint3D64f_z_set(CvPoint3D64f self, double z)"},
{ (char *)"CvPoint3D64f_z_get", _wrap_CvPoint3D64f_z_get, METH_VARARGS, (char *)"CvPoint3D64f_z_get(CvPoint3D64f self) -> double"},
{ (char *)"new_CvPoint3D64f", _wrap_new_CvPoint3D64f, METH_VARARGS, (char *)"new_CvPoint3D64f() -> CvPoint3D64f"},
{ (char *)"delete_CvPoint3D64f", _wrap_delete_CvPoint3D64f, METH_VARARGS, (char *)"delete_CvPoint3D64f(CvPoint3D64f self)"},
{ (char *)"CvPoint3D64f_swigregister", CvPoint3D64f_swigregister, METH_VARARGS, NULL},
{ (char *)"cvPoint3D64f", _wrap_cvPoint3D64f, METH_VARARGS, (char *)"cvPoint3D64f(double x, double y, double z) -> CvPoint3D64f"},
{ (char *)"CvSize_width_set", _wrap_CvSize_width_set, METH_VARARGS, (char *)"CvSize_width_set(CvSize self, int width)"},
{ (char *)"CvSize_width_get", _wrap_CvSize_width_get, METH_VARARGS, (char *)"CvSize_width_get(CvSize self) -> int"},
{ (char *)"CvSize_height_set", _wrap_CvSize_height_set, METH_VARARGS, (char *)"CvSize_height_set(CvSize self, int height)"},
{ (char *)"CvSize_height_get", _wrap_CvSize_height_get, METH_VARARGS, (char *)"CvSize_height_get(CvSize self) -> int"},
{ (char *)"new_CvSize", _wrap_new_CvSize, METH_VARARGS, (char *)"new_CvSize() -> CvSize"},
{ (char *)"delete_CvSize", _wrap_delete_CvSize, METH_VARARGS, (char *)"delete_CvSize(CvSize self)"},
{ (char *)"CvSize_swigregister", CvSize_swigregister, METH_VARARGS, NULL},
{ (char *)"cvSize", _wrap_cvSize, METH_VARARGS, (char *)"cvSize(int width, int height) -> CvSize"},
{ (char *)"CvSize2D32f_width_set", _wrap_CvSize2D32f_width_set, METH_VARARGS, (char *)"CvSize2D32f_width_set(CvSize2D32f self, float width)"},
{ (char *)"CvSize2D32f_width_get", _wrap_CvSize2D32f_width_get, METH_VARARGS, (char *)"CvSize2D32f_width_get(CvSize2D32f self) -> float"},
{ (char *)"CvSize2D32f_height_set", _wrap_CvSize2D32f_height_set, METH_VARARGS, (char *)"CvSize2D32f_height_set(CvSize2D32f self, float height)"},
{ (char *)"CvSize2D32f_height_get", _wrap_CvSize2D32f_height_get, METH_VARARGS, (char *)"CvSize2D32f_height_get(CvSize2D32f self) -> float"},
{ (char *)"new_CvSize2D32f", _wrap_new_CvSize2D32f, METH_VARARGS, (char *)"new_CvSize2D32f() -> CvSize2D32f"},
{ (char *)"delete_CvSize2D32f", _wrap_delete_CvSize2D32f, METH_VARARGS, (char *)"delete_CvSize2D32f(CvSize2D32f self)"},
{ (char *)"CvSize2D32f_swigregister", CvSize2D32f_swigregister, METH_VARARGS, NULL},
{ (char *)"cvSize2D32f", _wrap_cvSize2D32f, METH_VARARGS, (char *)"cvSize2D32f(double width, double height) -> CvSize2D32f"},
{ (char *)"CvBox2D_center_set", _wrap_CvBox2D_center_set, METH_VARARGS, (char *)"CvBox2D_center_set(CvBox2D self, CvPoint2D32f center)"},
{ (char *)"CvBox2D_center_get", _wrap_CvBox2D_center_get, METH_VARARGS, (char *)"CvBox2D_center_get(CvBox2D self) -> CvPoint2D32f"},
{ (char *)"CvBox2D_size_set", _wrap_CvBox2D_size_set, METH_VARARGS, (char *)"CvBox2D_size_set(CvBox2D self, CvSize2D32f size)"},
{ (char *)"CvBox2D_size_get", _wrap_CvBox2D_size_get, METH_VARARGS, (char *)"CvBox2D_size_get(CvBox2D self) -> CvSize2D32f"},
{ (char *)"CvBox2D_angle_set", _wrap_CvBox2D_angle_set, METH_VARARGS, (char *)"CvBox2D_angle_set(CvBox2D self, float angle)"},
{ (char *)"CvBox2D_angle_get", _wrap_CvBox2D_angle_get, METH_VARARGS, (char *)"CvBox2D_angle_get(CvBox2D self) -> float"},
{ (char *)"new_CvBox2D", _wrap_new_CvBox2D, METH_VARARGS, (char *)"new_CvBox2D() -> CvBox2D"},
{ (char *)"delete_CvBox2D", _wrap_delete_CvBox2D, METH_VARARGS, (char *)"delete_CvBox2D(CvBox2D self)"},
{ (char *)"CvBox2D_swigregister", CvBox2D_swigregister, METH_VARARGS, NULL},
{ (char *)"CvLineIterator_ptr_set", _wrap_CvLineIterator_ptr_set, METH_VARARGS, (char *)"CvLineIterator_ptr_set(CvLineIterator self, uchar ptr)"},
{ (char *)"CvLineIterator_ptr_get", _wrap_CvLineIterator_ptr_get, METH_VARARGS, (char *)"CvLineIterator_ptr_get(CvLineIterator self) -> uchar"},
{ (char *)"CvLineIterator_err_set", _wrap_CvLineIterator_err_set, METH_VARARGS, (char *)"CvLineIterator_err_set(CvLineIterator self, int err)"},
{ (char *)"CvLineIterator_err_get", _wrap_CvLineIterator_err_get, METH_VARARGS, (char *)"CvLineIterator_err_get(CvLineIterator self) -> int"},
{ (char *)"CvLineIterator_plus_delta_set", _wrap_CvLineIterator_plus_delta_set, METH_VARARGS, (char *)"CvLineIterator_plus_delta_set(CvLineIterator self, int plus_delta)"},
{ (char *)"CvLineIterator_plus_delta_get", _wrap_CvLineIterator_plus_delta_get, METH_VARARGS, (char *)"CvLineIterator_plus_delta_get(CvLineIterator self) -> int"},
{ (char *)"CvLineIterator_minus_delta_set", _wrap_CvLineIterator_minus_delta_set, METH_VARARGS, (char *)"CvLineIterator_minus_delta_set(CvLineIterator self, int minus_delta)"},
{ (char *)"CvLineIterator_minus_delta_get", _wrap_CvLineIterator_minus_delta_get, METH_VARARGS, (char *)"CvLineIterator_minus_delta_get(CvLineIterator self) -> int"},
{ (char *)"CvLineIterator_plus_step_set", _wrap_CvLineIterator_plus_step_set, METH_VARARGS, (char *)"CvLineIterator_plus_step_set(CvLineIterator self, int plus_step)"},
{ (char *)"CvLineIterator_plus_step_get", _wrap_CvLineIterator_plus_step_get, METH_VARARGS, (char *)"CvLineIterator_plus_step_get(CvLineIterator self) -> int"},
{ (char *)"CvLineIterator_minus_step_set", _wrap_CvLineIterator_minus_step_set, METH_VARARGS, (char *)"CvLineIterator_minus_step_set(CvLineIterator self, int minus_step)"},
{ (char *)"CvLineIterator_minus_step_get", _wrap_CvLineIterator_minus_step_get, METH_VARARGS, (char *)"CvLineIterator_minus_step_get(CvLineIterator self) -> int"},
{ (char *)"new_CvLineIterator", _wrap_new_CvLineIterator, METH_VARARGS, (char *)"new_CvLineIterator() -> CvLineIterator"},
{ (char *)"delete_CvLineIterator", _wrap_delete_CvLineIterator, METH_VARARGS, (char *)"delete_CvLineIterator(CvLineIterator self)"},
{ (char *)"CvLineIterator_swigregister", CvLineIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSlice_start_index_set", _wrap_CvSlice_start_index_set, METH_VARARGS, (char *)"CvSlice_start_index_set(CvSlice self, int start_index)"},
{ (char *)"CvSlice_start_index_get", _wrap_CvSlice_start_index_get, METH_VARARGS, (char *)"CvSlice_start_index_get(CvSlice self) -> int"},
{ (char *)"CvSlice_end_index_set", _wrap_CvSlice_end_index_set, METH_VARARGS, (char *)"CvSlice_end_index_set(CvSlice self, int end_index)"},
{ (char *)"CvSlice_end_index_get", _wrap_CvSlice_end_index_get, METH_VARARGS, (char *)"CvSlice_end_index_get(CvSlice self) -> int"},
{ (char *)"new_CvSlice", _wrap_new_CvSlice, METH_VARARGS, (char *)"new_CvSlice() -> CvSlice"},
{ (char *)"delete_CvSlice", _wrap_delete_CvSlice, METH_VARARGS, (char *)"delete_CvSlice(CvSlice self)"},
{ (char *)"CvSlice_swigregister", CvSlice_swigregister, METH_VARARGS, NULL},
{ (char *)"cvSlice", _wrap_cvSlice, METH_VARARGS, (char *)"cvSlice(int start, int end) -> CvSlice"},
{ (char *)"CvScalar_val_set", _wrap_CvScalar_val_set, METH_VARARGS, (char *)"CvScalar_val_set(CvScalar self, double val)"},
{ (char *)"CvScalar_val_get", _wrap_CvScalar_val_get, METH_VARARGS, (char *)"CvScalar_val_get(CvScalar self) -> double"},
{ (char *)"CvScalar___str__", _wrap_CvScalar___str__, METH_VARARGS, (char *)"CvScalar___str__(CvScalar self) -> char"},
{ (char *)"CvScalar___repr__", _wrap_CvScalar___repr__, METH_VARARGS, (char *)"CvScalar___repr__(CvScalar self) -> char"},
{ (char *)"CvScalar___getitem__", _wrap_CvScalar___getitem__, METH_VARARGS, (char *)"CvScalar___getitem__(CvScalar self, int index) -> double"},
{ (char *)"CvScalar___setitem__", _wrap_CvScalar___setitem__, METH_VARARGS, (char *)"CvScalar___setitem__(CvScalar self, int index, double value)"},
{ (char *)"new_CvScalar", _wrap_new_CvScalar, METH_VARARGS, (char *)"new_CvScalar() -> CvScalar"},
{ (char *)"delete_CvScalar", _wrap_delete_CvScalar, METH_VARARGS, (char *)"delete_CvScalar(CvScalar self)"},
{ (char *)"CvScalar_swigregister", CvScalar_swigregister, METH_VARARGS, NULL},
{ (char *)"cvScalar", _wrap_cvScalar, METH_VARARGS, (char *)"\n"
"cvScalar(double val0, double val1=0, double val2=0, double val3=0) -> CvScalar\n"
"cvScalar(double val0, double val1=0, double val2=0) -> CvScalar\n"
"cvScalar(double val0, double val1=0) -> CvScalar\n"
"cvScalar(double val0) -> CvScalar\n"
""},
{ (char *)"cvRealScalar", _wrap_cvRealScalar, METH_VARARGS, (char *)"cvRealScalar(double val0) -> CvScalar"},
{ (char *)"cvScalarAll", _wrap_cvScalarAll, METH_VARARGS, (char *)"cvScalarAll(double val0123) -> CvScalar"},
{ (char *)"CvMemBlock_prev_set", _wrap_CvMemBlock_prev_set, METH_VARARGS, (char *)"CvMemBlock_prev_set(CvMemBlock self, CvMemBlock prev)"},
{ (char *)"CvMemBlock_prev_get", _wrap_CvMemBlock_prev_get, METH_VARARGS, (char *)"CvMemBlock_prev_get(CvMemBlock self) -> CvMemBlock"},
{ (char *)"CvMemBlock_next_set", _wrap_CvMemBlock_next_set, METH_VARARGS, (char *)"CvMemBlock_next_set(CvMemBlock self, CvMemBlock next)"},
{ (char *)"CvMemBlock_next_get", _wrap_CvMemBlock_next_get, METH_VARARGS, (char *)"CvMemBlock_next_get(CvMemBlock self) -> CvMemBlock"},
{ (char *)"new_CvMemBlock", _wrap_new_CvMemBlock, METH_VARARGS, (char *)"new_CvMemBlock() -> CvMemBlock"},
{ (char *)"delete_CvMemBlock", _wrap_delete_CvMemBlock, METH_VARARGS, (char *)"delete_CvMemBlock(CvMemBlock self)"},
{ (char *)"CvMemBlock_swigregister", CvMemBlock_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMemStorage_signature_set", _wrap_CvMemStorage_signature_set, METH_VARARGS, (char *)"CvMemStorage_signature_set(CvMemStorage self, int signature)"},
{ (char *)"CvMemStorage_signature_get", _wrap_CvMemStorage_signature_get, METH_VARARGS, (char *)"CvMemStorage_signature_get(CvMemStorage self) -> int"},
{ (char *)"CvMemStorage_bottom_set", _wrap_CvMemStorage_bottom_set, METH_VARARGS, (char *)"CvMemStorage_bottom_set(CvMemStorage self, CvMemBlock bottom)"},
{ (char *)"CvMemStorage_bottom_get", _wrap_CvMemStorage_bottom_get, METH_VARARGS, (char *)"CvMemStorage_bottom_get(CvMemStorage self) -> CvMemBlock"},
{ (char *)"CvMemStorage_top_set", _wrap_CvMemStorage_top_set, METH_VARARGS, (char *)"CvMemStorage_top_set(CvMemStorage self, CvMemBlock top)"},
{ (char *)"CvMemStorage_top_get", _wrap_CvMemStorage_top_get, METH_VARARGS, (char *)"CvMemStorage_top_get(CvMemStorage self) -> CvMemBlock"},
{ (char *)"CvMemStorage_parent_set", _wrap_CvMemStorage_parent_set, METH_VARARGS, (char *)"CvMemStorage_parent_set(CvMemStorage self, CvMemStorage parent)"},
{ (char *)"CvMemStorage_parent_get", _wrap_CvMemStorage_parent_get, METH_VARARGS, (char *)"CvMemStorage_parent_get(CvMemStorage self) -> CvMemStorage"},
{ (char *)"CvMemStorage_block_size_set", _wrap_CvMemStorage_block_size_set, METH_VARARGS, (char *)"CvMemStorage_block_size_set(CvMemStorage self, int block_size)"},
{ (char *)"CvMemStorage_block_size_get", _wrap_CvMemStorage_block_size_get, METH_VARARGS, (char *)"CvMemStorage_block_size_get(CvMemStorage self) -> int"},
{ (char *)"CvMemStorage_free_space_set", _wrap_CvMemStorage_free_space_set, METH_VARARGS, (char *)"CvMemStorage_free_space_set(CvMemStorage self, int free_space)"},
{ (char *)"CvMemStorage_free_space_get", _wrap_CvMemStorage_free_space_get, METH_VARARGS, (char *)"CvMemStorage_free_space_get(CvMemStorage self) -> int"},
{ (char *)"delete_CvMemStorage", _wrap_delete_CvMemStorage, METH_VARARGS, (char *)"delete_CvMemStorage(CvMemStorage self)"},
{ (char *)"CvMemStorage_swigregister", CvMemStorage_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMemStoragePos_top_set", _wrap_CvMemStoragePos_top_set, METH_VARARGS, (char *)"CvMemStoragePos_top_set(CvMemStoragePos self, CvMemBlock top)"},
{ (char *)"CvMemStoragePos_top_get", _wrap_CvMemStoragePos_top_get, METH_VARARGS, (char *)"CvMemStoragePos_top_get(CvMemStoragePos self) -> CvMemBlock"},
{ (char *)"CvMemStoragePos_free_space_set", _wrap_CvMemStoragePos_free_space_set, METH_VARARGS, (char *)"CvMemStoragePos_free_space_set(CvMemStoragePos self, int free_space)"},
{ (char *)"CvMemStoragePos_free_space_get", _wrap_CvMemStoragePos_free_space_get, METH_VARARGS, (char *)"CvMemStoragePos_free_space_get(CvMemStoragePos self) -> int"},
{ (char *)"new_CvMemStoragePos", _wrap_new_CvMemStoragePos, METH_VARARGS, (char *)"new_CvMemStoragePos() -> CvMemStoragePos"},
{ (char *)"delete_CvMemStoragePos", _wrap_delete_CvMemStoragePos, METH_VARARGS, (char *)"delete_CvMemStoragePos(CvMemStoragePos self)"},
{ (char *)"CvMemStoragePos_swigregister", CvMemStoragePos_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeqBlock_prev_set", _wrap_CvSeqBlock_prev_set, METH_VARARGS, (char *)"CvSeqBlock_prev_set(CvSeqBlock self, CvSeqBlock prev)"},
{ (char *)"CvSeqBlock_prev_get", _wrap_CvSeqBlock_prev_get, METH_VARARGS, (char *)"CvSeqBlock_prev_get(CvSeqBlock self) -> CvSeqBlock"},
{ (char *)"CvSeqBlock_next_set", _wrap_CvSeqBlock_next_set, METH_VARARGS, (char *)"CvSeqBlock_next_set(CvSeqBlock self, CvSeqBlock next)"},
{ (char *)"CvSeqBlock_next_get", _wrap_CvSeqBlock_next_get, METH_VARARGS, (char *)"CvSeqBlock_next_get(CvSeqBlock self) -> CvSeqBlock"},
{ (char *)"CvSeqBlock_start_index_set", _wrap_CvSeqBlock_start_index_set, METH_VARARGS, (char *)"CvSeqBlock_start_index_set(CvSeqBlock self, int start_index)"},
{ (char *)"CvSeqBlock_start_index_get", _wrap_CvSeqBlock_start_index_get, METH_VARARGS, (char *)"CvSeqBlock_start_index_get(CvSeqBlock self) -> int"},
{ (char *)"CvSeqBlock_count_set", _wrap_CvSeqBlock_count_set, METH_VARARGS, (char *)"CvSeqBlock_count_set(CvSeqBlock self, int count)"},
{ (char *)"CvSeqBlock_count_get", _wrap_CvSeqBlock_count_get, METH_VARARGS, (char *)"CvSeqBlock_count_get(CvSeqBlock self) -> int"},
{ (char *)"CvSeqBlock_data_set", _wrap_CvSeqBlock_data_set, METH_VARARGS, (char *)"CvSeqBlock_data_set(CvSeqBlock self, schar data)"},
{ (char *)"CvSeqBlock_data_get", _wrap_CvSeqBlock_data_get, METH_VARARGS, (char *)"CvSeqBlock_data_get(CvSeqBlock self) -> schar"},
{ (char *)"new_CvSeqBlock", _wrap_new_CvSeqBlock, METH_VARARGS, (char *)"new_CvSeqBlock() -> CvSeqBlock"},
{ (char *)"delete_CvSeqBlock", _wrap_delete_CvSeqBlock, METH_VARARGS, (char *)"delete_CvSeqBlock(CvSeqBlock self)"},
{ (char *)"CvSeqBlock_swigregister", CvSeqBlock_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_flags_set", _wrap_CvSeq_flags_set, METH_VARARGS, (char *)"CvSeq_flags_set(CvSeq self, int flags)"},
{ (char *)"CvSeq_flags_get", _wrap_CvSeq_flags_get, METH_VARARGS, (char *)"CvSeq_flags_get(CvSeq self) -> int"},
{ (char *)"CvSeq_header_size_set", _wrap_CvSeq_header_size_set, METH_VARARGS, (char *)"CvSeq_header_size_set(CvSeq self, int header_size)"},
{ (char *)"CvSeq_header_size_get", _wrap_CvSeq_header_size_get, METH_VARARGS, (char *)"CvSeq_header_size_get(CvSeq self) -> int"},
{ (char *)"CvSeq_h_prev_set", _wrap_CvSeq_h_prev_set, METH_VARARGS, (char *)"CvSeq_h_prev_set(CvSeq self, CvSeq h_prev)"},
{ (char *)"CvSeq_h_prev_get", _wrap_CvSeq_h_prev_get, METH_VARARGS, (char *)"CvSeq_h_prev_get(CvSeq self) -> CvSeq"},
{ (char *)"CvSeq_h_next_set", _wrap_CvSeq_h_next_set, METH_VARARGS, (char *)"CvSeq_h_next_set(CvSeq self, CvSeq h_next)"},
{ (char *)"CvSeq_h_next_get", _wrap_CvSeq_h_next_get, METH_VARARGS, (char *)"CvSeq_h_next_get(CvSeq self) -> CvSeq"},
{ (char *)"CvSeq_v_prev_set", _wrap_CvSeq_v_prev_set, METH_VARARGS, (char *)"CvSeq_v_prev_set(CvSeq self, CvSeq v_prev)"},
{ (char *)"CvSeq_v_prev_get", _wrap_CvSeq_v_prev_get, METH_VARARGS, (char *)"CvSeq_v_prev_get(CvSeq self) -> CvSeq"},
{ (char *)"CvSeq_v_next_set", _wrap_CvSeq_v_next_set, METH_VARARGS, (char *)"CvSeq_v_next_set(CvSeq self, CvSeq v_next)"},
{ (char *)"CvSeq_v_next_get", _wrap_CvSeq_v_next_get, METH_VARARGS, (char *)"CvSeq_v_next_get(CvSeq self) -> CvSeq"},
{ (char *)"CvSeq_total_set", _wrap_CvSeq_total_set, METH_VARARGS, (char *)"CvSeq_total_set(CvSeq self, int total)"},
{ (char *)"CvSeq_total_get", _wrap_CvSeq_total_get, METH_VARARGS, (char *)"CvSeq_total_get(CvSeq self) -> int"},
{ (char *)"CvSeq_elem_size_set", _wrap_CvSeq_elem_size_set, METH_VARARGS, (char *)"CvSeq_elem_size_set(CvSeq self, int elem_size)"},
{ (char *)"CvSeq_elem_size_get", _wrap_CvSeq_elem_size_get, METH_VARARGS, (char *)"CvSeq_elem_size_get(CvSeq self) -> int"},
{ (char *)"CvSeq_block_max_set", _wrap_CvSeq_block_max_set, METH_VARARGS, (char *)"CvSeq_block_max_set(CvSeq self, schar block_max)"},
{ (char *)"CvSeq_block_max_get", _wrap_CvSeq_block_max_get, METH_VARARGS, (char *)"CvSeq_block_max_get(CvSeq self) -> schar"},
{ (char *)"CvSeq_ptr_set", _wrap_CvSeq_ptr_set, METH_VARARGS, (char *)"CvSeq_ptr_set(CvSeq self, schar ptr)"},
{ (char *)"CvSeq_ptr_get", _wrap_CvSeq_ptr_get, METH_VARARGS, (char *)"CvSeq_ptr_get(CvSeq self) -> schar"},
{ (char *)"CvSeq_delta_elems_set", _wrap_CvSeq_delta_elems_set, METH_VARARGS, (char *)"CvSeq_delta_elems_set(CvSeq self, int delta_elems)"},
{ (char *)"CvSeq_delta_elems_get", _wrap_CvSeq_delta_elems_get, METH_VARARGS, (char *)"CvSeq_delta_elems_get(CvSeq self) -> int"},
{ (char *)"CvSeq_storage_set", _wrap_CvSeq_storage_set, METH_VARARGS, (char *)"CvSeq_storage_set(CvSeq self, CvMemStorage storage)"},
{ (char *)"CvSeq_storage_get", _wrap_CvSeq_storage_get, METH_VARARGS, (char *)"CvSeq_storage_get(CvSeq self) -> CvMemStorage"},
{ (char *)"CvSeq_free_blocks_set", _wrap_CvSeq_free_blocks_set, METH_VARARGS, (char *)"CvSeq_free_blocks_set(CvSeq self, CvSeqBlock free_blocks)"},
{ (char *)"CvSeq_free_blocks_get", _wrap_CvSeq_free_blocks_get, METH_VARARGS, (char *)"CvSeq_free_blocks_get(CvSeq self) -> CvSeqBlock"},
{ (char *)"CvSeq_first_set", _wrap_CvSeq_first_set, METH_VARARGS, (char *)"CvSeq_first_set(CvSeq self, CvSeqBlock first)"},
{ (char *)"CvSeq_first_get", _wrap_CvSeq_first_get, METH_VARARGS, (char *)"CvSeq_first_get(CvSeq self) -> CvSeqBlock"},
{ (char *)"new_CvSeq", _wrap_new_CvSeq, METH_VARARGS, (char *)"new_CvSeq() -> CvSeq"},
{ (char *)"delete_CvSeq", _wrap_delete_CvSeq, METH_VARARGS, (char *)"delete_CvSeq(CvSeq self)"},
{ (char *)"CvSeq_swigregister", CvSeq_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSetElem_flags_set", _wrap_CvSetElem_flags_set, METH_VARARGS, (char *)"CvSetElem_flags_set(CvSetElem self, int flags)"},
{ (char *)"CvSetElem_flags_get", _wrap_CvSetElem_flags_get, METH_VARARGS, (char *)"CvSetElem_flags_get(CvSetElem self) -> int"},
{ (char *)"CvSetElem_next_free_set", _wrap_CvSetElem_next_free_set, METH_VARARGS, (char *)"CvSetElem_next_free_set(CvSetElem self, CvSetElem next_free)"},
{ (char *)"CvSetElem_next_free_get", _wrap_CvSetElem_next_free_get, METH_VARARGS, (char *)"CvSetElem_next_free_get(CvSetElem self) -> CvSetElem"},
{ (char *)"new_CvSetElem", _wrap_new_CvSetElem, METH_VARARGS, (char *)"new_CvSetElem() -> CvSetElem"},
{ (char *)"delete_CvSetElem", _wrap_delete_CvSetElem, METH_VARARGS, (char *)"delete_CvSetElem(CvSetElem self)"},
{ (char *)"CvSetElem_swigregister", CvSetElem_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSet_flags_set", _wrap_CvSet_flags_set, METH_VARARGS, (char *)"CvSet_flags_set(CvSet self, int flags)"},
{ (char *)"CvSet_flags_get", _wrap_CvSet_flags_get, METH_VARARGS, (char *)"CvSet_flags_get(CvSet self) -> int"},
{ (char *)"CvSet_header_size_set", _wrap_CvSet_header_size_set, METH_VARARGS, (char *)"CvSet_header_size_set(CvSet self, int header_size)"},
{ (char *)"CvSet_header_size_get", _wrap_CvSet_header_size_get, METH_VARARGS, (char *)"CvSet_header_size_get(CvSet self) -> int"},
{ (char *)"CvSet_h_prev_set", _wrap_CvSet_h_prev_set, METH_VARARGS, (char *)"CvSet_h_prev_set(CvSet self, CvSeq h_prev)"},
{ (char *)"CvSet_h_prev_get", _wrap_CvSet_h_prev_get, METH_VARARGS, (char *)"CvSet_h_prev_get(CvSet self) -> CvSeq"},
{ (char *)"CvSet_h_next_set", _wrap_CvSet_h_next_set, METH_VARARGS, (char *)"CvSet_h_next_set(CvSet self, CvSeq h_next)"},
{ (char *)"CvSet_h_next_get", _wrap_CvSet_h_next_get, METH_VARARGS, (char *)"CvSet_h_next_get(CvSet self) -> CvSeq"},
{ (char *)"CvSet_v_prev_set", _wrap_CvSet_v_prev_set, METH_VARARGS, (char *)"CvSet_v_prev_set(CvSet self, CvSeq v_prev)"},
{ (char *)"CvSet_v_prev_get", _wrap_CvSet_v_prev_get, METH_VARARGS, (char *)"CvSet_v_prev_get(CvSet self) -> CvSeq"},
{ (char *)"CvSet_v_next_set", _wrap_CvSet_v_next_set, METH_VARARGS, (char *)"CvSet_v_next_set(CvSet self, CvSeq v_next)"},
{ (char *)"CvSet_v_next_get", _wrap_CvSet_v_next_get, METH_VARARGS, (char *)"CvSet_v_next_get(CvSet self) -> CvSeq"},
{ (char *)"CvSet_total_set", _wrap_CvSet_total_set, METH_VARARGS, (char *)"CvSet_total_set(CvSet self, int total)"},
{ (char *)"CvSet_total_get", _wrap_CvSet_total_get, METH_VARARGS, (char *)"CvSet_total_get(CvSet self) -> int"},
{ (char *)"CvSet_elem_size_set", _wrap_CvSet_elem_size_set, METH_VARARGS, (char *)"CvSet_elem_size_set(CvSet self, int elem_size)"},
{ (char *)"CvSet_elem_size_get", _wrap_CvSet_elem_size_get, METH_VARARGS, (char *)"CvSet_elem_size_get(CvSet self) -> int"},
{ (char *)"CvSet_block_max_set", _wrap_CvSet_block_max_set, METH_VARARGS, (char *)"CvSet_block_max_set(CvSet self, schar block_max)"},
{ (char *)"CvSet_block_max_get", _wrap_CvSet_block_max_get, METH_VARARGS, (char *)"CvSet_block_max_get(CvSet self) -> schar"},
{ (char *)"CvSet_ptr_set", _wrap_CvSet_ptr_set, METH_VARARGS, (char *)"CvSet_ptr_set(CvSet self, schar ptr)"},
{ (char *)"CvSet_ptr_get", _wrap_CvSet_ptr_get, METH_VARARGS, (char *)"CvSet_ptr_get(CvSet self) -> schar"},
{ (char *)"CvSet_delta_elems_set", _wrap_CvSet_delta_elems_set, METH_VARARGS, (char *)"CvSet_delta_elems_set(CvSet self, int delta_elems)"},
{ (char *)"CvSet_delta_elems_get", _wrap_CvSet_delta_elems_get, METH_VARARGS, (char *)"CvSet_delta_elems_get(CvSet self) -> int"},
{ (char *)"CvSet_storage_set", _wrap_CvSet_storage_set, METH_VARARGS, (char *)"CvSet_storage_set(CvSet self, CvMemStorage storage)"},
{ (char *)"CvSet_storage_get", _wrap_CvSet_storage_get, METH_VARARGS, (char *)"CvSet_storage_get(CvSet self) -> CvMemStorage"},
{ (char *)"CvSet_free_blocks_set", _wrap_CvSet_free_blocks_set, METH_VARARGS, (char *)"CvSet_free_blocks_set(CvSet self, CvSeqBlock free_blocks)"},
{ (char *)"CvSet_free_blocks_get", _wrap_CvSet_free_blocks_get, METH_VARARGS, (char *)"CvSet_free_blocks_get(CvSet self) -> CvSeqBlock"},
{ (char *)"CvSet_first_set", _wrap_CvSet_first_set, METH_VARARGS, (char *)"CvSet_first_set(CvSet self, CvSeqBlock first)"},
{ (char *)"CvSet_first_get", _wrap_CvSet_first_get, METH_VARARGS, (char *)"CvSet_first_get(CvSet self) -> CvSeqBlock"},
{ (char *)"CvSet_free_elems_set", _wrap_CvSet_free_elems_set, METH_VARARGS, (char *)"CvSet_free_elems_set(CvSet self, CvSetElem free_elems)"},
{ (char *)"CvSet_free_elems_get", _wrap_CvSet_free_elems_get, METH_VARARGS, (char *)"CvSet_free_elems_get(CvSet self) -> CvSetElem"},
{ (char *)"CvSet_active_count_set", _wrap_CvSet_active_count_set, METH_VARARGS, (char *)"CvSet_active_count_set(CvSet self, int active_count)"},
{ (char *)"CvSet_active_count_get", _wrap_CvSet_active_count_get, METH_VARARGS, (char *)"CvSet_active_count_get(CvSet self) -> int"},
{ (char *)"new_CvSet", _wrap_new_CvSet, METH_VARARGS, (char *)"new_CvSet() -> CvSet"},
{ (char *)"delete_CvSet", _wrap_delete_CvSet, METH_VARARGS, (char *)"delete_CvSet(CvSet self)"},
{ (char *)"CvSet_swigregister", CvSet_swigregister, METH_VARARGS, NULL},
{ (char *)"CvGraphEdge_flags_set", _wrap_CvGraphEdge_flags_set, METH_VARARGS, (char *)"CvGraphEdge_flags_set(CvGraphEdge self, int flags)"},
{ (char *)"CvGraphEdge_flags_get", _wrap_CvGraphEdge_flags_get, METH_VARARGS, (char *)"CvGraphEdge_flags_get(CvGraphEdge self) -> int"},
{ (char *)"CvGraphEdge_weight_set", _wrap_CvGraphEdge_weight_set, METH_VARARGS, (char *)"CvGraphEdge_weight_set(CvGraphEdge self, float weight)"},
{ (char *)"CvGraphEdge_weight_get", _wrap_CvGraphEdge_weight_get, METH_VARARGS, (char *)"CvGraphEdge_weight_get(CvGraphEdge self) -> float"},
{ (char *)"CvGraphEdge_next_set", _wrap_CvGraphEdge_next_set, METH_VARARGS, (char *)"CvGraphEdge_next_set(CvGraphEdge self, CvGraphEdge next)"},
{ (char *)"CvGraphEdge_next_get", _wrap_CvGraphEdge_next_get, METH_VARARGS, (char *)"CvGraphEdge_next_get(CvGraphEdge self) -> CvGraphEdge"},
{ (char *)"CvGraphEdge_vtx_set", _wrap_CvGraphEdge_vtx_set, METH_VARARGS, (char *)"CvGraphEdge_vtx_set(CvGraphEdge self, CvGraphVtx vtx)"},
{ (char *)"CvGraphEdge_vtx_get", _wrap_CvGraphEdge_vtx_get, METH_VARARGS, (char *)"CvGraphEdge_vtx_get(CvGraphEdge self) -> CvGraphVtx"},
{ (char *)"new_CvGraphEdge", _wrap_new_CvGraphEdge, METH_VARARGS, (char *)"new_CvGraphEdge() -> CvGraphEdge"},
{ (char *)"delete_CvGraphEdge", _wrap_delete_CvGraphEdge, METH_VARARGS, (char *)"delete_CvGraphEdge(CvGraphEdge self)"},
{ (char *)"CvGraphEdge_swigregister", CvGraphEdge_swigregister, METH_VARARGS, NULL},
{ (char *)"CvGraphVtx_flags_set", _wrap_CvGraphVtx_flags_set, METH_VARARGS, (char *)"CvGraphVtx_flags_set(CvGraphVtx self, int flags)"},
{ (char *)"CvGraphVtx_flags_get", _wrap_CvGraphVtx_flags_get, METH_VARARGS, (char *)"CvGraphVtx_flags_get(CvGraphVtx self) -> int"},
{ (char *)"CvGraphVtx_first_set", _wrap_CvGraphVtx_first_set, METH_VARARGS, (char *)"CvGraphVtx_first_set(CvGraphVtx self, CvGraphEdge first)"},
{ (char *)"CvGraphVtx_first_get", _wrap_CvGraphVtx_first_get, METH_VARARGS, (char *)"CvGraphVtx_first_get(CvGraphVtx self) -> CvGraphEdge"},
{ (char *)"new_CvGraphVtx", _wrap_new_CvGraphVtx, METH_VARARGS, (char *)"new_CvGraphVtx() -> CvGraphVtx"},
{ (char *)"delete_CvGraphVtx", _wrap_delete_CvGraphVtx, METH_VARARGS, (char *)"delete_CvGraphVtx(CvGraphVtx self)"},
{ (char *)"CvGraphVtx_swigregister", CvGraphVtx_swigregister, METH_VARARGS, NULL},
{ (char *)"CvGraphVtx2D_flags_set", _wrap_CvGraphVtx2D_flags_set, METH_VARARGS, (char *)"CvGraphVtx2D_flags_set(CvGraphVtx2D self, int flags)"},
{ (char *)"CvGraphVtx2D_flags_get", _wrap_CvGraphVtx2D_flags_get, METH_VARARGS, (char *)"CvGraphVtx2D_flags_get(CvGraphVtx2D self) -> int"},
{ (char *)"CvGraphVtx2D_first_set", _wrap_CvGraphVtx2D_first_set, METH_VARARGS, (char *)"CvGraphVtx2D_first_set(CvGraphVtx2D self, CvGraphEdge first)"},
{ (char *)"CvGraphVtx2D_first_get", _wrap_CvGraphVtx2D_first_get, METH_VARARGS, (char *)"CvGraphVtx2D_first_get(CvGraphVtx2D self) -> CvGraphEdge"},
{ (char *)"CvGraphVtx2D_ptr_set", _wrap_CvGraphVtx2D_ptr_set, METH_VARARGS, (char *)"CvGraphVtx2D_ptr_set(CvGraphVtx2D self, CvPoint2D32f ptr)"},
{ (char *)"CvGraphVtx2D_ptr_get", _wrap_CvGraphVtx2D_ptr_get, METH_VARARGS, (char *)"CvGraphVtx2D_ptr_get(CvGraphVtx2D self) -> CvPoint2D32f"},
{ (char *)"new_CvGraphVtx2D", _wrap_new_CvGraphVtx2D, METH_VARARGS, (char *)"new_CvGraphVtx2D() -> CvGraphVtx2D"},
{ (char *)"delete_CvGraphVtx2D", _wrap_delete_CvGraphVtx2D, METH_VARARGS, (char *)"delete_CvGraphVtx2D(CvGraphVtx2D self)"},
{ (char *)"CvGraphVtx2D_swigregister", CvGraphVtx2D_swigregister, METH_VARARGS, NULL},
{ (char *)"CvGraph_flags_set", _wrap_CvGraph_flags_set, METH_VARARGS, (char *)"CvGraph_flags_set(CvGraph self, int flags)"},
{ (char *)"CvGraph_flags_get", _wrap_CvGraph_flags_get, METH_VARARGS, (char *)"CvGraph_flags_get(CvGraph self) -> int"},
{ (char *)"CvGraph_header_size_set", _wrap_CvGraph_header_size_set, METH_VARARGS, (char *)"CvGraph_header_size_set(CvGraph self, int header_size)"},
{ (char *)"CvGraph_header_size_get", _wrap_CvGraph_header_size_get, METH_VARARGS, (char *)"CvGraph_header_size_get(CvGraph self) -> int"},
{ (char *)"CvGraph_h_prev_set", _wrap_CvGraph_h_prev_set, METH_VARARGS, (char *)"CvGraph_h_prev_set(CvGraph self, CvSeq h_prev)"},
{ (char *)"CvGraph_h_prev_get", _wrap_CvGraph_h_prev_get, METH_VARARGS, (char *)"CvGraph_h_prev_get(CvGraph self) -> CvSeq"},
{ (char *)"CvGraph_h_next_set", _wrap_CvGraph_h_next_set, METH_VARARGS, (char *)"CvGraph_h_next_set(CvGraph self, CvSeq h_next)"},
{ (char *)"CvGraph_h_next_get", _wrap_CvGraph_h_next_get, METH_VARARGS, (char *)"CvGraph_h_next_get(CvGraph self) -> CvSeq"},
{ (char *)"CvGraph_v_prev_set", _wrap_CvGraph_v_prev_set, METH_VARARGS, (char *)"CvGraph_v_prev_set(CvGraph self, CvSeq v_prev)"},
{ (char *)"CvGraph_v_prev_get", _wrap_CvGraph_v_prev_get, METH_VARARGS, (char *)"CvGraph_v_prev_get(CvGraph self) -> CvSeq"},
{ (char *)"CvGraph_v_next_set", _wrap_CvGraph_v_next_set, METH_VARARGS, (char *)"CvGraph_v_next_set(CvGraph self, CvSeq v_next)"},
{ (char *)"CvGraph_v_next_get", _wrap_CvGraph_v_next_get, METH_VARARGS, (char *)"CvGraph_v_next_get(CvGraph self) -> CvSeq"},
{ (char *)"CvGraph_total_set", _wrap_CvGraph_total_set, METH_VARARGS, (char *)"CvGraph_total_set(CvGraph self, int total)"},
{ (char *)"CvGraph_total_get", _wrap_CvGraph_total_get, METH_VARARGS, (char *)"CvGraph_total_get(CvGraph self) -> int"},
{ (char *)"CvGraph_elem_size_set", _wrap_CvGraph_elem_size_set, METH_VARARGS, (char *)"CvGraph_elem_size_set(CvGraph self, int elem_size)"},
{ (char *)"CvGraph_elem_size_get", _wrap_CvGraph_elem_size_get, METH_VARARGS, (char *)"CvGraph_elem_size_get(CvGraph self) -> int"},
{ (char *)"CvGraph_block_max_set", _wrap_CvGraph_block_max_set, METH_VARARGS, (char *)"CvGraph_block_max_set(CvGraph self, schar block_max)"},
{ (char *)"CvGraph_block_max_get", _wrap_CvGraph_block_max_get, METH_VARARGS, (char *)"CvGraph_block_max_get(CvGraph self) -> schar"},
{ (char *)"CvGraph_ptr_set", _wrap_CvGraph_ptr_set, METH_VARARGS, (char *)"CvGraph_ptr_set(CvGraph self, schar ptr)"},
{ (char *)"CvGraph_ptr_get", _wrap_CvGraph_ptr_get, METH_VARARGS, (char *)"CvGraph_ptr_get(CvGraph self) -> schar"},
{ (char *)"CvGraph_delta_elems_set", _wrap_CvGraph_delta_elems_set, METH_VARARGS, (char *)"CvGraph_delta_elems_set(CvGraph self, int delta_elems)"},
{ (char *)"CvGraph_delta_elems_get", _wrap_CvGraph_delta_elems_get, METH_VARARGS, (char *)"CvGraph_delta_elems_get(CvGraph self) -> int"},
{ (char *)"CvGraph_storage_set", _wrap_CvGraph_storage_set, METH_VARARGS, (char *)"CvGraph_storage_set(CvGraph self, CvMemStorage storage)"},
{ (char *)"CvGraph_storage_get", _wrap_CvGraph_storage_get, METH_VARARGS, (char *)"CvGraph_storage_get(CvGraph self) -> CvMemStorage"},
{ (char *)"CvGraph_free_blocks_set", _wrap_CvGraph_free_blocks_set, METH_VARARGS, (char *)"CvGraph_free_blocks_set(CvGraph self, CvSeqBlock free_blocks)"},
{ (char *)"CvGraph_free_blocks_get", _wrap_CvGraph_free_blocks_get, METH_VARARGS, (char *)"CvGraph_free_blocks_get(CvGraph self) -> CvSeqBlock"},
{ (char *)"CvGraph_first_set", _wrap_CvGraph_first_set, METH_VARARGS, (char *)"CvGraph_first_set(CvGraph self, CvSeqBlock first)"},
{ (char *)"CvGraph_first_get", _wrap_CvGraph_first_get, METH_VARARGS, (char *)"CvGraph_first_get(CvGraph self) -> CvSeqBlock"},
{ (char *)"CvGraph_free_elems_set", _wrap_CvGraph_free_elems_set, METH_VARARGS, (char *)"CvGraph_free_elems_set(CvGraph self, CvSetElem free_elems)"},
{ (char *)"CvGraph_free_elems_get", _wrap_CvGraph_free_elems_get, METH_VARARGS, (char *)"CvGraph_free_elems_get(CvGraph self) -> CvSetElem"},
{ (char *)"CvGraph_active_count_set", _wrap_CvGraph_active_count_set, METH_VARARGS, (char *)"CvGraph_active_count_set(CvGraph self, int active_count)"},
{ (char *)"CvGraph_active_count_get", _wrap_CvGraph_active_count_get, METH_VARARGS, (char *)"CvGraph_active_count_get(CvGraph self) -> int"},
{ (char *)"CvGraph_edges_set", _wrap_CvGraph_edges_set, METH_VARARGS, (char *)"CvGraph_edges_set(CvGraph self, CvSet edges)"},
{ (char *)"CvGraph_edges_get", _wrap_CvGraph_edges_get, METH_VARARGS, (char *)"CvGraph_edges_get(CvGraph self) -> CvSet"},
{ (char *)"new_CvGraph", _wrap_new_CvGraph, METH_VARARGS, (char *)"new_CvGraph() -> CvGraph"},
{ (char *)"delete_CvGraph", _wrap_delete_CvGraph, METH_VARARGS, (char *)"delete_CvGraph(CvGraph self)"},
{ (char *)"CvGraph_swigregister", CvGraph_swigregister, METH_VARARGS, NULL},
{ (char *)"CvChain_flags_set", _wrap_CvChain_flags_set, METH_VARARGS, (char *)"CvChain_flags_set(CvChain self, int flags)"},
{ (char *)"CvChain_flags_get", _wrap_CvChain_flags_get, METH_VARARGS, (char *)"CvChain_flags_get(CvChain self) -> int"},
{ (char *)"CvChain_header_size_set", _wrap_CvChain_header_size_set, METH_VARARGS, (char *)"CvChain_header_size_set(CvChain self, int header_size)"},
{ (char *)"CvChain_header_size_get", _wrap_CvChain_header_size_get, METH_VARARGS, (char *)"CvChain_header_size_get(CvChain self) -> int"},
{ (char *)"CvChain_h_prev_set", _wrap_CvChain_h_prev_set, METH_VARARGS, (char *)"CvChain_h_prev_set(CvChain self, CvSeq h_prev)"},
{ (char *)"CvChain_h_prev_get", _wrap_CvChain_h_prev_get, METH_VARARGS, (char *)"CvChain_h_prev_get(CvChain self) -> CvSeq"},
{ (char *)"CvChain_h_next_set", _wrap_CvChain_h_next_set, METH_VARARGS, (char *)"CvChain_h_next_set(CvChain self, CvSeq h_next)"},
{ (char *)"CvChain_h_next_get", _wrap_CvChain_h_next_get, METH_VARARGS, (char *)"CvChain_h_next_get(CvChain self) -> CvSeq"},
{ (char *)"CvChain_v_prev_set", _wrap_CvChain_v_prev_set, METH_VARARGS, (char *)"CvChain_v_prev_set(CvChain self, CvSeq v_prev)"},
{ (char *)"CvChain_v_prev_get", _wrap_CvChain_v_prev_get, METH_VARARGS, (char *)"CvChain_v_prev_get(CvChain self) -> CvSeq"},
{ (char *)"CvChain_v_next_set", _wrap_CvChain_v_next_set, METH_VARARGS, (char *)"CvChain_v_next_set(CvChain self, CvSeq v_next)"},
{ (char *)"CvChain_v_next_get", _wrap_CvChain_v_next_get, METH_VARARGS, (char *)"CvChain_v_next_get(CvChain self) -> CvSeq"},
{ (char *)"CvChain_total_set", _wrap_CvChain_total_set, METH_VARARGS, (char *)"CvChain_total_set(CvChain self, int total)"},
{ (char *)"CvChain_total_get", _wrap_CvChain_total_get, METH_VARARGS, (char *)"CvChain_total_get(CvChain self) -> int"},
{ (char *)"CvChain_elem_size_set", _wrap_CvChain_elem_size_set, METH_VARARGS, (char *)"CvChain_elem_size_set(CvChain self, int elem_size)"},
{ (char *)"CvChain_elem_size_get", _wrap_CvChain_elem_size_get, METH_VARARGS, (char *)"CvChain_elem_size_get(CvChain self) -> int"},
{ (char *)"CvChain_block_max_set", _wrap_CvChain_block_max_set, METH_VARARGS, (char *)"CvChain_block_max_set(CvChain self, schar block_max)"},
{ (char *)"CvChain_block_max_get", _wrap_CvChain_block_max_get, METH_VARARGS, (char *)"CvChain_block_max_get(CvChain self) -> schar"},
{ (char *)"CvChain_ptr_set", _wrap_CvChain_ptr_set, METH_VARARGS, (char *)"CvChain_ptr_set(CvChain self, schar ptr)"},
{ (char *)"CvChain_ptr_get", _wrap_CvChain_ptr_get, METH_VARARGS, (char *)"CvChain_ptr_get(CvChain self) -> schar"},
{ (char *)"CvChain_delta_elems_set", _wrap_CvChain_delta_elems_set, METH_VARARGS, (char *)"CvChain_delta_elems_set(CvChain self, int delta_elems)"},
{ (char *)"CvChain_delta_elems_get", _wrap_CvChain_delta_elems_get, METH_VARARGS, (char *)"CvChain_delta_elems_get(CvChain self) -> int"},
{ (char *)"CvChain_storage_set", _wrap_CvChain_storage_set, METH_VARARGS, (char *)"CvChain_storage_set(CvChain self, CvMemStorage storage)"},
{ (char *)"CvChain_storage_get", _wrap_CvChain_storage_get, METH_VARARGS, (char *)"CvChain_storage_get(CvChain self) -> CvMemStorage"},
{ (char *)"CvChain_free_blocks_set", _wrap_CvChain_free_blocks_set, METH_VARARGS, (char *)"CvChain_free_blocks_set(CvChain self, CvSeqBlock free_blocks)"},
{ (char *)"CvChain_free_blocks_get", _wrap_CvChain_free_blocks_get, METH_VARARGS, (char *)"CvChain_free_blocks_get(CvChain self) -> CvSeqBlock"},
{ (char *)"CvChain_first_set", _wrap_CvChain_first_set, METH_VARARGS, (char *)"CvChain_first_set(CvChain self, CvSeqBlock first)"},
{ (char *)"CvChain_first_get", _wrap_CvChain_first_get, METH_VARARGS, (char *)"CvChain_first_get(CvChain self) -> CvSeqBlock"},
{ (char *)"CvChain_origin_set", _wrap_CvChain_origin_set, METH_VARARGS, (char *)"CvChain_origin_set(CvChain self, CvPoint origin)"},
{ (char *)"CvChain_origin_get", _wrap_CvChain_origin_get, METH_VARARGS, (char *)"CvChain_origin_get(CvChain self) -> CvPoint"},
{ (char *)"new_CvChain", _wrap_new_CvChain, METH_VARARGS, (char *)"new_CvChain() -> CvChain"},
{ (char *)"delete_CvChain", _wrap_delete_CvChain, METH_VARARGS, (char *)"delete_CvChain(CvChain self)"},
{ (char *)"CvChain_swigregister", CvChain_swigregister, METH_VARARGS, NULL},
{ (char *)"CvContour_flags_set", _wrap_CvContour_flags_set, METH_VARARGS, (char *)"CvContour_flags_set(CvContour self, int flags)"},
{ (char *)"CvContour_flags_get", _wrap_CvContour_flags_get, METH_VARARGS, (char *)"CvContour_flags_get(CvContour self) -> int"},
{ (char *)"CvContour_header_size_set", _wrap_CvContour_header_size_set, METH_VARARGS, (char *)"CvContour_header_size_set(CvContour self, int header_size)"},
{ (char *)"CvContour_header_size_get", _wrap_CvContour_header_size_get, METH_VARARGS, (char *)"CvContour_header_size_get(CvContour self) -> int"},
{ (char *)"CvContour_h_prev_set", _wrap_CvContour_h_prev_set, METH_VARARGS, (char *)"CvContour_h_prev_set(CvContour self, CvSeq h_prev)"},
{ (char *)"CvContour_h_prev_get", _wrap_CvContour_h_prev_get, METH_VARARGS, (char *)"CvContour_h_prev_get(CvContour self) -> CvSeq"},
{ (char *)"CvContour_h_next_set", _wrap_CvContour_h_next_set, METH_VARARGS, (char *)"CvContour_h_next_set(CvContour self, CvSeq h_next)"},
{ (char *)"CvContour_h_next_get", _wrap_CvContour_h_next_get, METH_VARARGS, (char *)"CvContour_h_next_get(CvContour self) -> CvSeq"},
{ (char *)"CvContour_v_prev_set", _wrap_CvContour_v_prev_set, METH_VARARGS, (char *)"CvContour_v_prev_set(CvContour self, CvSeq v_prev)"},
{ (char *)"CvContour_v_prev_get", _wrap_CvContour_v_prev_get, METH_VARARGS, (char *)"CvContour_v_prev_get(CvContour self) -> CvSeq"},
{ (char *)"CvContour_v_next_set", _wrap_CvContour_v_next_set, METH_VARARGS, (char *)"CvContour_v_next_set(CvContour self, CvSeq v_next)"},
{ (char *)"CvContour_v_next_get", _wrap_CvContour_v_next_get, METH_VARARGS, (char *)"CvContour_v_next_get(CvContour self) -> CvSeq"},
{ (char *)"CvContour_total_set", _wrap_CvContour_total_set, METH_VARARGS, (char *)"CvContour_total_set(CvContour self, int total)"},
{ (char *)"CvContour_total_get", _wrap_CvContour_total_get, METH_VARARGS, (char *)"CvContour_total_get(CvContour self) -> int"},
{ (char *)"CvContour_elem_size_set", _wrap_CvContour_elem_size_set, METH_VARARGS, (char *)"CvContour_elem_size_set(CvContour self, int elem_size)"},
{ (char *)"CvContour_elem_size_get", _wrap_CvContour_elem_size_get, METH_VARARGS, (char *)"CvContour_elem_size_get(CvContour self) -> int"},
{ (char *)"CvContour_block_max_set", _wrap_CvContour_block_max_set, METH_VARARGS, (char *)"CvContour_block_max_set(CvContour self, schar block_max)"},
{ (char *)"CvContour_block_max_get", _wrap_CvContour_block_max_get, METH_VARARGS, (char *)"CvContour_block_max_get(CvContour self) -> schar"},
{ (char *)"CvContour_ptr_set", _wrap_CvContour_ptr_set, METH_VARARGS, (char *)"CvContour_ptr_set(CvContour self, schar ptr)"},
{ (char *)"CvContour_ptr_get", _wrap_CvContour_ptr_get, METH_VARARGS, (char *)"CvContour_ptr_get(CvContour self) -> schar"},
{ (char *)"CvContour_delta_elems_set", _wrap_CvContour_delta_elems_set, METH_VARARGS, (char *)"CvContour_delta_elems_set(CvContour self, int delta_elems)"},
{ (char *)"CvContour_delta_elems_get", _wrap_CvContour_delta_elems_get, METH_VARARGS, (char *)"CvContour_delta_elems_get(CvContour self) -> int"},
{ (char *)"CvContour_storage_set", _wrap_CvContour_storage_set, METH_VARARGS, (char *)"CvContour_storage_set(CvContour self, CvMemStorage storage)"},
{ (char *)"CvContour_storage_get", _wrap_CvContour_storage_get, METH_VARARGS, (char *)"CvContour_storage_get(CvContour self) -> CvMemStorage"},
{ (char *)"CvContour_free_blocks_set", _wrap_CvContour_free_blocks_set, METH_VARARGS, (char *)"CvContour_free_blocks_set(CvContour self, CvSeqBlock free_blocks)"},
{ (char *)"CvContour_free_blocks_get", _wrap_CvContour_free_blocks_get, METH_VARARGS, (char *)"CvContour_free_blocks_get(CvContour self) -> CvSeqBlock"},
{ (char *)"CvContour_first_set", _wrap_CvContour_first_set, METH_VARARGS, (char *)"CvContour_first_set(CvContour self, CvSeqBlock first)"},
{ (char *)"CvContour_first_get", _wrap_CvContour_first_get, METH_VARARGS, (char *)"CvContour_first_get(CvContour self) -> CvSeqBlock"},
{ (char *)"CvContour_rect_set", _wrap_CvContour_rect_set, METH_VARARGS, (char *)"CvContour_rect_set(CvContour self, CvRect rect)"},
{ (char *)"CvContour_rect_get", _wrap_CvContour_rect_get, METH_VARARGS, (char *)"CvContour_rect_get(CvContour self) -> CvRect"},
{ (char *)"CvContour_color_set", _wrap_CvContour_color_set, METH_VARARGS, (char *)"CvContour_color_set(CvContour self, int color)"},
{ (char *)"CvContour_color_get", _wrap_CvContour_color_get, METH_VARARGS, (char *)"CvContour_color_get(CvContour self) -> int"},
{ (char *)"CvContour_reserved_set", _wrap_CvContour_reserved_set, METH_VARARGS, (char *)"CvContour_reserved_set(CvContour self, int reserved)"},
{ (char *)"CvContour_reserved_get", _wrap_CvContour_reserved_get, METH_VARARGS, (char *)"CvContour_reserved_get(CvContour self) -> int"},
{ (char *)"new_CvContour", _wrap_new_CvContour, METH_VARARGS, (char *)"new_CvContour() -> CvContour"},
{ (char *)"delete_CvContour", _wrap_delete_CvContour, METH_VARARGS, (char *)"delete_CvContour(CvContour self)"},
{ (char *)"CvContour_swigregister", CvContour_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeqWriter_header_size_set", _wrap_CvSeqWriter_header_size_set, METH_VARARGS, (char *)"CvSeqWriter_header_size_set(CvSeqWriter self, int header_size)"},
{ (char *)"CvSeqWriter_header_size_get", _wrap_CvSeqWriter_header_size_get, METH_VARARGS, (char *)"CvSeqWriter_header_size_get(CvSeqWriter self) -> int"},
{ (char *)"CvSeqWriter_seq_set", _wrap_CvSeqWriter_seq_set, METH_VARARGS, (char *)"CvSeqWriter_seq_set(CvSeqWriter self, CvSeq seq)"},
{ (char *)"CvSeqWriter_seq_get", _wrap_CvSeqWriter_seq_get, METH_VARARGS, (char *)"CvSeqWriter_seq_get(CvSeqWriter self) -> CvSeq"},
{ (char *)"CvSeqWriter_block_set", _wrap_CvSeqWriter_block_set, METH_VARARGS, (char *)"CvSeqWriter_block_set(CvSeqWriter self, CvSeqBlock block)"},
{ (char *)"CvSeqWriter_block_get", _wrap_CvSeqWriter_block_get, METH_VARARGS, (char *)"CvSeqWriter_block_get(CvSeqWriter self) -> CvSeqBlock"},
{ (char *)"CvSeqWriter_ptr_set", _wrap_CvSeqWriter_ptr_set, METH_VARARGS, (char *)"CvSeqWriter_ptr_set(CvSeqWriter self, schar ptr)"},
{ (char *)"CvSeqWriter_ptr_get", _wrap_CvSeqWriter_ptr_get, METH_VARARGS, (char *)"CvSeqWriter_ptr_get(CvSeqWriter self) -> schar"},
{ (char *)"CvSeqWriter_block_min_set", _wrap_CvSeqWriter_block_min_set, METH_VARARGS, (char *)"CvSeqWriter_block_min_set(CvSeqWriter self, schar block_min)"},
{ (char *)"CvSeqWriter_block_min_get", _wrap_CvSeqWriter_block_min_get, METH_VARARGS, (char *)"CvSeqWriter_block_min_get(CvSeqWriter self) -> schar"},
{ (char *)"CvSeqWriter_block_max_set", _wrap_CvSeqWriter_block_max_set, METH_VARARGS, (char *)"CvSeqWriter_block_max_set(CvSeqWriter self, schar block_max)"},
{ (char *)"CvSeqWriter_block_max_get", _wrap_CvSeqWriter_block_max_get, METH_VARARGS, (char *)"CvSeqWriter_block_max_get(CvSeqWriter self) -> schar"},
{ (char *)"new_CvSeqWriter", _wrap_new_CvSeqWriter, METH_VARARGS, (char *)"new_CvSeqWriter() -> CvSeqWriter"},
{ (char *)"delete_CvSeqWriter", _wrap_delete_CvSeqWriter, METH_VARARGS, (char *)"delete_CvSeqWriter(CvSeqWriter self)"},
{ (char *)"CvSeqWriter_swigregister", CvSeqWriter_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeqReader_header_size_set", _wrap_CvSeqReader_header_size_set, METH_VARARGS, (char *)"CvSeqReader_header_size_set(CvSeqReader self, int header_size)"},
{ (char *)"CvSeqReader_header_size_get", _wrap_CvSeqReader_header_size_get, METH_VARARGS, (char *)"CvSeqReader_header_size_get(CvSeqReader self) -> int"},
{ (char *)"CvSeqReader_seq_set", _wrap_CvSeqReader_seq_set, METH_VARARGS, (char *)"CvSeqReader_seq_set(CvSeqReader self, CvSeq seq)"},
{ (char *)"CvSeqReader_seq_get", _wrap_CvSeqReader_seq_get, METH_VARARGS, (char *)"CvSeqReader_seq_get(CvSeqReader self) -> CvSeq"},
{ (char *)"CvSeqReader_block_set", _wrap_CvSeqReader_block_set, METH_VARARGS, (char *)"CvSeqReader_block_set(CvSeqReader self, CvSeqBlock block)"},
{ (char *)"CvSeqReader_block_get", _wrap_CvSeqReader_block_get, METH_VARARGS, (char *)"CvSeqReader_block_get(CvSeqReader self) -> CvSeqBlock"},
{ (char *)"CvSeqReader_ptr_set", _wrap_CvSeqReader_ptr_set, METH_VARARGS, (char *)"CvSeqReader_ptr_set(CvSeqReader self, schar ptr)"},
{ (char *)"CvSeqReader_ptr_get", _wrap_CvSeqReader_ptr_get, METH_VARARGS, (char *)"CvSeqReader_ptr_get(CvSeqReader self) -> schar"},
{ (char *)"CvSeqReader_block_min_set", _wrap_CvSeqReader_block_min_set, METH_VARARGS, (char *)"CvSeqReader_block_min_set(CvSeqReader self, schar block_min)"},
{ (char *)"CvSeqReader_block_min_get", _wrap_CvSeqReader_block_min_get, METH_VARARGS, (char *)"CvSeqReader_block_min_get(CvSeqReader self) -> schar"},
{ (char *)"CvSeqReader_block_max_set", _wrap_CvSeqReader_block_max_set, METH_VARARGS, (char *)"CvSeqReader_block_max_set(CvSeqReader self, schar block_max)"},
{ (char *)"CvSeqReader_block_max_get", _wrap_CvSeqReader_block_max_get, METH_VARARGS, (char *)"CvSeqReader_block_max_get(CvSeqReader self) -> schar"},
{ (char *)"CvSeqReader_delta_index_set", _wrap_CvSeqReader_delta_index_set, METH_VARARGS, (char *)"CvSeqReader_delta_index_set(CvSeqReader self, int delta_index)"},
{ (char *)"CvSeqReader_delta_index_get", _wrap_CvSeqReader_delta_index_get, METH_VARARGS, (char *)"CvSeqReader_delta_index_get(CvSeqReader self) -> int"},
{ (char *)"CvSeqReader_prev_elem_set", _wrap_CvSeqReader_prev_elem_set, METH_VARARGS, (char *)"CvSeqReader_prev_elem_set(CvSeqReader self, schar prev_elem)"},
{ (char *)"CvSeqReader_prev_elem_get", _wrap_CvSeqReader_prev_elem_get, METH_VARARGS, (char *)"CvSeqReader_prev_elem_get(CvSeqReader self) -> schar"},
{ (char *)"new_CvSeqReader", _wrap_new_CvSeqReader, METH_VARARGS, (char *)"new_CvSeqReader() -> CvSeqReader"},
{ (char *)"delete_CvSeqReader", _wrap_delete_CvSeqReader, METH_VARARGS, (char *)"delete_CvSeqReader(CvSeqReader self)"},
{ (char *)"CvSeqReader_swigregister", CvSeqReader_swigregister, METH_VARARGS, NULL},
{ (char *)"CvAttrList_attr_set", _wrap_CvAttrList_attr_set, METH_VARARGS, (char *)"CvAttrList_attr_set(CvAttrList self, char attr)"},
{ (char *)"CvAttrList_attr_get", _wrap_CvAttrList_attr_get, METH_VARARGS, (char *)"CvAttrList_attr_get(CvAttrList self) -> char"},
{ (char *)"CvAttrList_next_set", _wrap_CvAttrList_next_set, METH_VARARGS, (char *)"CvAttrList_next_set(CvAttrList self, CvAttrList next)"},
{ (char *)"CvAttrList_next_get", _wrap_CvAttrList_next_get, METH_VARARGS, (char *)"CvAttrList_next_get(CvAttrList self) -> CvAttrList"},
{ (char *)"new_CvAttrList", _wrap_new_CvAttrList, METH_VARARGS, (char *)"new_CvAttrList() -> CvAttrList"},
{ (char *)"delete_CvAttrList", _wrap_delete_CvAttrList, METH_VARARGS, (char *)"delete_CvAttrList(CvAttrList self)"},
{ (char *)"CvAttrList_swigregister", CvAttrList_swigregister, METH_VARARGS, NULL},
{ (char *)"cvAttrList", _wrap_cvAttrList, METH_VARARGS, (char *)"\n"
"cvAttrList(char attr=None, CvAttrList next=None) -> CvAttrList\n"
"cvAttrList(char attr=None) -> CvAttrList\n"
"cvAttrList() -> CvAttrList\n"
""},
{ (char *)"CvString_len_set", _wrap_CvString_len_set, METH_VARARGS, (char *)"CvString_len_set(CvString self, int len)"},
{ (char *)"CvString_len_get", _wrap_CvString_len_get, METH_VARARGS, (char *)"CvString_len_get(CvString self) -> int"},
{ (char *)"CvString_ptr_set", _wrap_CvString_ptr_set, METH_VARARGS, (char *)"CvString_ptr_set(CvString self, char ptr)"},
{ (char *)"CvString_ptr_get", _wrap_CvString_ptr_get, METH_VARARGS, (char *)"CvString_ptr_get(CvString self) -> char"},
{ (char *)"new_CvString", _wrap_new_CvString, METH_VARARGS, (char *)"new_CvString() -> CvString"},
{ (char *)"delete_CvString", _wrap_delete_CvString, METH_VARARGS, (char *)"delete_CvString(CvString self)"},
{ (char *)"CvString_swigregister", CvString_swigregister, METH_VARARGS, NULL},
{ (char *)"CvStringHashNode_hashval_set", _wrap_CvStringHashNode_hashval_set, METH_VARARGS, (char *)"CvStringHashNode_hashval_set(CvStringHashNode self, unsigned int hashval)"},
{ (char *)"CvStringHashNode_hashval_get", _wrap_CvStringHashNode_hashval_get, METH_VARARGS, (char *)"CvStringHashNode_hashval_get(CvStringHashNode self) -> unsigned int"},
{ (char *)"CvStringHashNode_str_set", _wrap_CvStringHashNode_str_set, METH_VARARGS, (char *)"CvStringHashNode_str_set(CvStringHashNode self, CvString str)"},
{ (char *)"CvStringHashNode_str_get", _wrap_CvStringHashNode_str_get, METH_VARARGS, (char *)"CvStringHashNode_str_get(CvStringHashNode self) -> CvString"},
{ (char *)"CvStringHashNode_next_set", _wrap_CvStringHashNode_next_set, METH_VARARGS, (char *)"CvStringHashNode_next_set(CvStringHashNode self, CvStringHashNode next)"},
{ (char *)"CvStringHashNode_next_get", _wrap_CvStringHashNode_next_get, METH_VARARGS, (char *)"CvStringHashNode_next_get(CvStringHashNode self) -> CvStringHashNode"},
{ (char *)"new_CvStringHashNode", _wrap_new_CvStringHashNode, METH_VARARGS, (char *)"new_CvStringHashNode() -> CvStringHashNode"},
{ (char *)"delete_CvStringHashNode", _wrap_delete_CvStringHashNode, METH_VARARGS, (char *)"delete_CvStringHashNode(CvStringHashNode self)"},
{ (char *)"CvStringHashNode_swigregister", CvStringHashNode_swigregister, METH_VARARGS, NULL},
{ (char *)"CvFileNode_tag_set", _wrap_CvFileNode_tag_set, METH_VARARGS, (char *)"CvFileNode_tag_set(CvFileNode self, int tag)"},
{ (char *)"CvFileNode_tag_get", _wrap_CvFileNode_tag_get, METH_VARARGS, (char *)"CvFileNode_tag_get(CvFileNode self) -> int"},
{ (char *)"CvFileNode_info_set", _wrap_CvFileNode_info_set, METH_VARARGS, (char *)"CvFileNode_info_set(CvFileNode self, CvTypeInfo info)"},
{ (char *)"CvFileNode_info_get", _wrap_CvFileNode_info_get, METH_VARARGS, (char *)"CvFileNode_info_get(CvFileNode self) -> CvTypeInfo"},
{ (char *)"CvFileNode_data_get", _wrap_CvFileNode_data_get, METH_VARARGS, (char *)"CvFileNode_data_get(CvFileNode self) -> CvFileNode_data"},
{ (char *)"new_CvFileNode", _wrap_new_CvFileNode, METH_VARARGS, (char *)"new_CvFileNode() -> CvFileNode"},
{ (char *)"delete_CvFileNode", _wrap_delete_CvFileNode, METH_VARARGS, (char *)"delete_CvFileNode(CvFileNode self)"},
{ (char *)"CvFileNode_swigregister", CvFileNode_swigregister, METH_VARARGS, NULL},
{ (char *)"CvFileNode_data_f_set", _wrap_CvFileNode_data_f_set, METH_VARARGS, (char *)"CvFileNode_data_f_set(CvFileNode_data self, double f)"},
{ (char *)"CvFileNode_data_f_get", _wrap_CvFileNode_data_f_get, METH_VARARGS, (char *)"CvFileNode_data_f_get(CvFileNode_data self) -> double"},
{ (char *)"CvFileNode_data_i_set", _wrap_CvFileNode_data_i_set, METH_VARARGS, (char *)"CvFileNode_data_i_set(CvFileNode_data self, int i)"},
{ (char *)"CvFileNode_data_i_get", _wrap_CvFileNode_data_i_get, METH_VARARGS, (char *)"CvFileNode_data_i_get(CvFileNode_data self) -> int"},
{ (char *)"CvFileNode_data_str_set", _wrap_CvFileNode_data_str_set, METH_VARARGS, (char *)"CvFileNode_data_str_set(CvFileNode_data self, CvString str)"},
{ (char *)"CvFileNode_data_str_get", _wrap_CvFileNode_data_str_get, METH_VARARGS, (char *)"CvFileNode_data_str_get(CvFileNode_data self) -> CvString"},
{ (char *)"CvFileNode_data_seq_set", _wrap_CvFileNode_data_seq_set, METH_VARARGS, (char *)"CvFileNode_data_seq_set(CvFileNode_data self, CvSeq seq)"},
{ (char *)"CvFileNode_data_seq_get", _wrap_CvFileNode_data_seq_get, METH_VARARGS, (char *)"CvFileNode_data_seq_get(CvFileNode_data self) -> CvSeq"},
{ (char *)"CvFileNode_data_map_set", _wrap_CvFileNode_data_map_set, METH_VARARGS, (char *)"CvFileNode_data_map_set(CvFileNode_data self, CvFileNodeHash map)"},
{ (char *)"CvFileNode_data_map_get", _wrap_CvFileNode_data_map_get, METH_VARARGS, (char *)"CvFileNode_data_map_get(CvFileNode_data self) -> CvFileNodeHash"},
{ (char *)"new_CvFileNode_data", _wrap_new_CvFileNode_data, METH_VARARGS, (char *)"new_CvFileNode_data() -> CvFileNode_data"},
{ (char *)"delete_CvFileNode_data", _wrap_delete_CvFileNode_data, METH_VARARGS, (char *)"delete_CvFileNode_data(CvFileNode_data self)"},
{ (char *)"CvFileNode_data_swigregister", CvFileNode_data_swigregister, METH_VARARGS, NULL},
{ (char *)"CvTypeInfo_flags_set", _wrap_CvTypeInfo_flags_set, METH_VARARGS, (char *)"CvTypeInfo_flags_set(CvTypeInfo self, int flags)"},
{ (char *)"CvTypeInfo_flags_get", _wrap_CvTypeInfo_flags_get, METH_VARARGS, (char *)"CvTypeInfo_flags_get(CvTypeInfo self) -> int"},
{ (char *)"CvTypeInfo_header_size_set", _wrap_CvTypeInfo_header_size_set, METH_VARARGS, (char *)"CvTypeInfo_header_size_set(CvTypeInfo self, int header_size)"},
{ (char *)"CvTypeInfo_header_size_get", _wrap_CvTypeInfo_header_size_get, METH_VARARGS, (char *)"CvTypeInfo_header_size_get(CvTypeInfo self) -> int"},
{ (char *)"CvTypeInfo_prev_set", _wrap_CvTypeInfo_prev_set, METH_VARARGS, (char *)"CvTypeInfo_prev_set(CvTypeInfo self, CvTypeInfo prev)"},
{ (char *)"CvTypeInfo_prev_get", _wrap_CvTypeInfo_prev_get, METH_VARARGS, (char *)"CvTypeInfo_prev_get(CvTypeInfo self) -> CvTypeInfo"},
{ (char *)"CvTypeInfo_next_set", _wrap_CvTypeInfo_next_set, METH_VARARGS, (char *)"CvTypeInfo_next_set(CvTypeInfo self, CvTypeInfo next)"},
{ (char *)"CvTypeInfo_next_get", _wrap_CvTypeInfo_next_get, METH_VARARGS, (char *)"CvTypeInfo_next_get(CvTypeInfo self) -> CvTypeInfo"},
{ (char *)"CvTypeInfo_type_name_set", _wrap_CvTypeInfo_type_name_set, METH_VARARGS, (char *)"CvTypeInfo_type_name_set(CvTypeInfo self, char type_name)"},
{ (char *)"CvTypeInfo_type_name_get", _wrap_CvTypeInfo_type_name_get, METH_VARARGS, (char *)"CvTypeInfo_type_name_get(CvTypeInfo self) -> char"},
{ (char *)"CvTypeInfo_is_instance_set", _wrap_CvTypeInfo_is_instance_set, METH_VARARGS, (char *)"CvTypeInfo_is_instance_set(CvTypeInfo self, CvIsInstanceFunc is_instance)"},
{ (char *)"CvTypeInfo_is_instance_get", _wrap_CvTypeInfo_is_instance_get, METH_VARARGS, (char *)"CvTypeInfo_is_instance_get(CvTypeInfo self) -> CvIsInstanceFunc"},
{ (char *)"CvTypeInfo_release_set", _wrap_CvTypeInfo_release_set, METH_VARARGS, (char *)"CvTypeInfo_release_set(CvTypeInfo self, CvReleaseFunc release)"},
{ (char *)"CvTypeInfo_release_get", _wrap_CvTypeInfo_release_get, METH_VARARGS, (char *)"CvTypeInfo_release_get(CvTypeInfo self) -> CvReleaseFunc"},
{ (char *)"CvTypeInfo_read_set", _wrap_CvTypeInfo_read_set, METH_VARARGS, (char *)"CvTypeInfo_read_set(CvTypeInfo self, CvReadFunc read)"},
{ (char *)"CvTypeInfo_read_get", _wrap_CvTypeInfo_read_get, METH_VARARGS, (char *)"CvTypeInfo_read_get(CvTypeInfo self) -> CvReadFunc"},
{ (char *)"CvTypeInfo_write_set", _wrap_CvTypeInfo_write_set, METH_VARARGS, (char *)"CvTypeInfo_write_set(CvTypeInfo self, CvWriteFunc write)"},
{ (char *)"CvTypeInfo_write_get", _wrap_CvTypeInfo_write_get, METH_VARARGS, (char *)"CvTypeInfo_write_get(CvTypeInfo self) -> CvWriteFunc"},
{ (char *)"CvTypeInfo_clone_set", _wrap_CvTypeInfo_clone_set, METH_VARARGS, (char *)"CvTypeInfo_clone_set(CvTypeInfo self, CvCloneFunc clone)"},
{ (char *)"CvTypeInfo_clone_get", _wrap_CvTypeInfo_clone_get, METH_VARARGS, (char *)"CvTypeInfo_clone_get(CvTypeInfo self) -> CvCloneFunc"},
{ (char *)"new_CvTypeInfo", _wrap_new_CvTypeInfo, METH_VARARGS, (char *)"new_CvTypeInfo() -> CvTypeInfo"},
{ (char *)"delete_CvTypeInfo", _wrap_delete_CvTypeInfo, METH_VARARGS, (char *)"delete_CvTypeInfo(CvTypeInfo self)"},
{ (char *)"CvTypeInfo_swigregister", CvTypeInfo_swigregister, METH_VARARGS, NULL},
{ (char *)"CvPluginFuncInfo_func_addr_set", _wrap_CvPluginFuncInfo_func_addr_set, METH_VARARGS, (char *)"CvPluginFuncInfo_func_addr_set(CvPluginFuncInfo self, void func_addr)"},
{ (char *)"CvPluginFuncInfo_func_addr_get", _wrap_CvPluginFuncInfo_func_addr_get, METH_VARARGS, (char *)"CvPluginFuncInfo_func_addr_get(CvPluginFuncInfo self) -> void"},
{ (char *)"CvPluginFuncInfo_default_func_addr_set", _wrap_CvPluginFuncInfo_default_func_addr_set, METH_VARARGS, (char *)"CvPluginFuncInfo_default_func_addr_set(CvPluginFuncInfo self, void default_func_addr)"},
{ (char *)"CvPluginFuncInfo_default_func_addr_get", _wrap_CvPluginFuncInfo_default_func_addr_get, METH_VARARGS, (char *)"CvPluginFuncInfo_default_func_addr_get(CvPluginFuncInfo self) -> void"},
{ (char *)"CvPluginFuncInfo_func_names_set", _wrap_CvPluginFuncInfo_func_names_set, METH_VARARGS, (char *)"CvPluginFuncInfo_func_names_set(CvPluginFuncInfo self, char func_names)"},
{ (char *)"CvPluginFuncInfo_func_names_get", _wrap_CvPluginFuncInfo_func_names_get, METH_VARARGS, (char *)"CvPluginFuncInfo_func_names_get(CvPluginFuncInfo self) -> char"},
{ (char *)"CvPluginFuncInfo_search_modules_set", _wrap_CvPluginFuncInfo_search_modules_set, METH_VARARGS, (char *)"CvPluginFuncInfo_search_modules_set(CvPluginFuncInfo self, int search_modules)"},
{ (char *)"CvPluginFuncInfo_search_modules_get", _wrap_CvPluginFuncInfo_search_modules_get, METH_VARARGS, (char *)"CvPluginFuncInfo_search_modules_get(CvPluginFuncInfo self) -> int"},
{ (char *)"CvPluginFuncInfo_loaded_from_set", _wrap_CvPluginFuncInfo_loaded_from_set, METH_VARARGS, (char *)"CvPluginFuncInfo_loaded_from_set(CvPluginFuncInfo self, int loaded_from)"},
{ (char *)"CvPluginFuncInfo_loaded_from_get", _wrap_CvPluginFuncInfo_loaded_from_get, METH_VARARGS, (char *)"CvPluginFuncInfo_loaded_from_get(CvPluginFuncInfo self) -> int"},
{ (char *)"new_CvPluginFuncInfo", _wrap_new_CvPluginFuncInfo, METH_VARARGS, (char *)"new_CvPluginFuncInfo() -> CvPluginFuncInfo"},
{ (char *)"delete_CvPluginFuncInfo", _wrap_delete_CvPluginFuncInfo, METH_VARARGS, (char *)"delete_CvPluginFuncInfo(CvPluginFuncInfo self)"},
{ (char *)"CvPluginFuncInfo_swigregister", CvPluginFuncInfo_swigregister, METH_VARARGS, NULL},
{ (char *)"CvModuleInfo_next_set", _wrap_CvModuleInfo_next_set, METH_VARARGS, (char *)"CvModuleInfo_next_set(CvModuleInfo self, CvModuleInfo next)"},
{ (char *)"CvModuleInfo_next_get", _wrap_CvModuleInfo_next_get, METH_VARARGS, (char *)"CvModuleInfo_next_get(CvModuleInfo self) -> CvModuleInfo"},
{ (char *)"CvModuleInfo_name_set", _wrap_CvModuleInfo_name_set, METH_VARARGS, (char *)"CvModuleInfo_name_set(CvModuleInfo self, char name)"},
{ (char *)"CvModuleInfo_name_get", _wrap_CvModuleInfo_name_get, METH_VARARGS, (char *)"CvModuleInfo_name_get(CvModuleInfo self) -> char"},
{ (char *)"CvModuleInfo_version_set", _wrap_CvModuleInfo_version_set, METH_VARARGS, (char *)"CvModuleInfo_version_set(CvModuleInfo self, char version)"},
{ (char *)"CvModuleInfo_version_get", _wrap_CvModuleInfo_version_get, METH_VARARGS, (char *)"CvModuleInfo_version_get(CvModuleInfo self) -> char"},
{ (char *)"CvModuleInfo_func_tab_set", _wrap_CvModuleInfo_func_tab_set, METH_VARARGS, (char *)"CvModuleInfo_func_tab_set(CvModuleInfo self, CvPluginFuncInfo func_tab)"},
{ (char *)"CvModuleInfo_func_tab_get", _wrap_CvModuleInfo_func_tab_get, METH_VARARGS, (char *)"CvModuleInfo_func_tab_get(CvModuleInfo self) -> CvPluginFuncInfo"},
{ (char *)"new_CvModuleInfo", _wrap_new_CvModuleInfo, METH_VARARGS, (char *)"new_CvModuleInfo() -> CvModuleInfo"},
{ (char *)"delete_CvModuleInfo", _wrap_delete_CvModuleInfo, METH_VARARGS, (char *)"delete_CvModuleInfo(CvModuleInfo self)"},
{ (char *)"CvModuleInfo_swigregister", CvModuleInfo_swigregister, METH_VARARGS, NULL},
{ (char *)"cvAlloc", _wrap_cvAlloc, METH_VARARGS, (char *)"cvAlloc(size_t size) -> void"},
{ (char *)"cvFree_", _wrap_cvFree_, METH_VARARGS, (char *)"cvFree_(void ptr)"},
{ (char *)"cvResetImageROI", _wrap_cvResetImageROI, METH_VARARGS, (char *)"cvResetImageROI( image)"},
{ (char *)"cvCreateMatHeader", _wrap_cvCreateMatHeader, METH_VARARGS, (char *)"cvCreateMatHeader(int rows, int cols, int type) -> CvMat"},
{ (char *)"cvInitMatHeader", _wrap_cvInitMatHeader, METH_VARARGS, (char *)"\n"
"cvInitMatHeader(CvMat mat, int rows, int cols, int type, void data=None, \n"
" int step=0x7fffffff) -> CvMat\n"
""},
{ (char *)"cvCreateMat", _wrap_cvCreateMat, METH_VARARGS, (char *)"cvCreateMat(int rows, int cols, int type) -> CvMat"},
{ (char *)"cvDecRefData", _wrap_cvDecRefData, METH_VARARGS, (char *)"cvDecRefData(CvArr arr)"},
{ (char *)"cvIncRefData", _wrap_cvIncRefData, METH_VARARGS, (char *)"cvIncRefData(CvArr arr) -> int"},
{ (char *)"cvCloneMat", _wrap_cvCloneMat, METH_VARARGS, (char *)"cvCloneMat(CvMat mat) -> CvMat"},
{ (char *)"cvGetSubRect", _wrap_cvGetSubRect, METH_VARARGS, (char *)"cvGetSubRect(CvArr arr, CvMat submat, CvRect rect) -> CvMat"},
{ (char *)"cvGetRows", _wrap_cvGetRows, METH_VARARGS, (char *)"\n"
"cvGetRows(CvArr arr, CvMat submat, int start_row, int end_row, \n"
" int delta_row=1) -> CvMat\n"
""},
{ (char *)"cvGetRow", _wrap_cvGetRow, METH_VARARGS, (char *)"cvGetRow(CvArr arr, CvMat submat, int row) -> CvMat"},
{ (char *)"cvGetCols", _wrap_cvGetCols, METH_VARARGS, (char *)"cvGetCols(CvArr arr, CvMat submat, int start_col, int end_col) -> CvMat"},
{ (char *)"cvGetCol", _wrap_cvGetCol, METH_VARARGS, (char *)"cvGetCol(CvArr arr, CvMat submat, int col) -> CvMat"},
{ (char *)"cvGetDiag", _wrap_cvGetDiag, METH_VARARGS, (char *)"cvGetDiag(CvArr arr, CvMat submat, int diag=0) -> CvMat"},
{ (char *)"cvScalarToRawData", _wrap_cvScalarToRawData, METH_VARARGS, (char *)"cvScalarToRawData(CvScalar scalar, void data, int type, int extend_to_12=0)"},
{ (char *)"cvRawDataToScalar", _wrap_cvRawDataToScalar, METH_VARARGS, (char *)"cvRawDataToScalar(void data, int type, CvScalar scalar)"},
{ (char *)"cvCreateMatNDHeader", _wrap_cvCreateMatNDHeader, METH_VARARGS, (char *)"cvCreateMatNDHeader(int dims, int type) -> CvMatND"},
{ (char *)"cvCreateMatND", _wrap_cvCreateMatND, METH_VARARGS, (char *)"cvCreateMatND(int dims, int type) -> CvMatND"},
{ (char *)"cvInitMatNDHeader", _wrap_cvInitMatNDHeader, METH_VARARGS, (char *)"cvInitMatNDHeader(CvMatND mat, int dims, int type, void data=None) -> CvMatND"},
{ (char *)"cvCloneMatND", _wrap_cvCloneMatND, METH_VARARGS, (char *)"cvCloneMatND(CvMatND mat) -> CvMatND"},
{ (char *)"cvCreateSparseMat", _wrap_cvCreateSparseMat, METH_VARARGS, (char *)"cvCreateSparseMat(int dims, int type) -> CvSparseMat"},
{ (char *)"cvCloneSparseMat", _wrap_cvCloneSparseMat, METH_VARARGS, (char *)"cvCloneSparseMat(CvSparseMat mat) -> CvSparseMat"},
{ (char *)"cvInitSparseMatIterator", _wrap_cvInitSparseMatIterator, METH_VARARGS, (char *)"cvInitSparseMatIterator(CvSparseMat mat, CvSparseMatIterator mat_iterator) -> CvSparseNode"},
{ (char *)"cvGetNextSparseNode", _wrap_cvGetNextSparseNode, METH_VARARGS, (char *)"cvGetNextSparseNode(CvSparseMatIterator mat_iterator) -> CvSparseNode"},
{ (char *)"CvNArrayIterator_count_set", _wrap_CvNArrayIterator_count_set, METH_VARARGS, (char *)"CvNArrayIterator_count_set(CvNArrayIterator self, int count)"},
{ (char *)"CvNArrayIterator_count_get", _wrap_CvNArrayIterator_count_get, METH_VARARGS, (char *)"CvNArrayIterator_count_get(CvNArrayIterator self) -> int"},
{ (char *)"CvNArrayIterator_dims_set", _wrap_CvNArrayIterator_dims_set, METH_VARARGS, (char *)"CvNArrayIterator_dims_set(CvNArrayIterator self, int dims)"},
{ (char *)"CvNArrayIterator_dims_get", _wrap_CvNArrayIterator_dims_get, METH_VARARGS, (char *)"CvNArrayIterator_dims_get(CvNArrayIterator self) -> int"},
{ (char *)"CvNArrayIterator_size_set", _wrap_CvNArrayIterator_size_set, METH_VARARGS, (char *)"CvNArrayIterator_size_set(CvNArrayIterator self, CvSize size)"},
{ (char *)"CvNArrayIterator_size_get", _wrap_CvNArrayIterator_size_get, METH_VARARGS, (char *)"CvNArrayIterator_size_get(CvNArrayIterator self) -> CvSize"},
{ (char *)"CvNArrayIterator_ptr_set", _wrap_CvNArrayIterator_ptr_set, METH_VARARGS, (char *)"CvNArrayIterator_ptr_set(CvNArrayIterator self, uchar ptr)"},
{ (char *)"CvNArrayIterator_ptr_get", _wrap_CvNArrayIterator_ptr_get, METH_VARARGS, (char *)"CvNArrayIterator_ptr_get(CvNArrayIterator self) -> uchar"},
{ (char *)"CvNArrayIterator_stack_set", _wrap_CvNArrayIterator_stack_set, METH_VARARGS, (char *)"CvNArrayIterator_stack_set(CvNArrayIterator self, int stack)"},
{ (char *)"CvNArrayIterator_stack_get", _wrap_CvNArrayIterator_stack_get, METH_VARARGS, (char *)"CvNArrayIterator_stack_get(CvNArrayIterator self) -> int"},
{ (char *)"CvNArrayIterator_hdr_set", _wrap_CvNArrayIterator_hdr_set, METH_VARARGS, (char *)"CvNArrayIterator_hdr_set(CvNArrayIterator self, CvMatND hdr)"},
{ (char *)"CvNArrayIterator_hdr_get", _wrap_CvNArrayIterator_hdr_get, METH_VARARGS, (char *)"CvNArrayIterator_hdr_get(CvNArrayIterator self) -> CvMatND"},
{ (char *)"new_CvNArrayIterator", _wrap_new_CvNArrayIterator, METH_VARARGS, (char *)"new_CvNArrayIterator() -> CvNArrayIterator"},
{ (char *)"delete_CvNArrayIterator", _wrap_delete_CvNArrayIterator, METH_VARARGS, (char *)"delete_CvNArrayIterator(CvNArrayIterator self)"},
{ (char *)"CvNArrayIterator_swigregister", CvNArrayIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"cvInitNArrayIterator", _wrap_cvInitNArrayIterator, METH_VARARGS, (char *)"\n"
"cvInitNArrayIterator(int count, CvArr arrs, CvArr mask, CvMatND stubs, CvNArrayIterator array_iterator, \n"
" int flags=0) -> int\n"
""},
{ (char *)"cvNextNArraySlice", _wrap_cvNextNArraySlice, METH_VARARGS, (char *)"cvNextNArraySlice(CvNArrayIterator array_iterator) -> int"},
{ (char *)"cvGetElemType", _wrap_cvGetElemType, METH_VARARGS, (char *)"cvGetElemType(CvArr arr) -> int"},
{ (char *)"cvGetDims", _wrap_cvGetDims, METH_VARARGS, (char *)"cvGetDims(CvArr arr) -> int"},
{ (char *)"cvGetDimSize", _wrap_cvGetDimSize, METH_VARARGS, (char *)"cvGetDimSize(CvArr arr, int index) -> int"},
{ (char *)"cvPtr1D", _wrap_cvPtr1D, METH_VARARGS, (char *)"cvPtr1D(CvArr arr, int idx0, int type=None) -> uchar"},
{ (char *)"cvPtr2D", _wrap_cvPtr2D, METH_VARARGS, (char *)"cvPtr2D(CvArr arr, int idx0, int idx1, int type=None) -> uchar"},
{ (char *)"cvPtr3D", _wrap_cvPtr3D, METH_VARARGS, (char *)"cvPtr3D(CvArr arr, int idx0, int idx1, int idx2, int type=None) -> uchar"},
{ (char *)"cvPtrND", _wrap_cvPtrND, METH_VARARGS, (char *)"\n"
"cvPtrND(CvArr arr, int idx, int type=None, int create_node=1, \n"
" unsigned int precalc_hashval=None) -> uchar\n"
""},
{ (char *)"cvGet1D", _wrap_cvGet1D, METH_VARARGS, (char *)"cvGet1D(CvArr arr, int idx0) -> CvScalar"},
{ (char *)"cvGet2D", _wrap_cvGet2D, METH_VARARGS, (char *)"cvGet2D(CvArr arr, int idx0, int idx1) -> CvScalar"},
{ (char *)"cvGet3D", _wrap_cvGet3D, METH_VARARGS, (char *)"cvGet3D(CvArr arr, int idx0, int idx1, int idx2) -> CvScalar"},
{ (char *)"cvGetND", _wrap_cvGetND, METH_VARARGS, (char *)"cvGetND(CvArr arr, int idx) -> CvScalar"},
{ (char *)"cvGetReal1D", _wrap_cvGetReal1D, METH_VARARGS, (char *)"cvGetReal1D(CvArr arr, int idx0) -> double"},
{ (char *)"cvGetReal2D", _wrap_cvGetReal2D, METH_VARARGS, (char *)"cvGetReal2D(CvArr arr, int idx0, int idx1) -> double"},
{ (char *)"cvGetReal3D", _wrap_cvGetReal3D, METH_VARARGS, (char *)"cvGetReal3D(CvArr arr, int idx0, int idx1, int idx2) -> double"},
{ (char *)"cvGetRealND", _wrap_cvGetRealND, METH_VARARGS, (char *)"cvGetRealND(CvArr arr, int idx) -> double"},
{ (char *)"cvSet1D", _wrap_cvSet1D, METH_VARARGS, (char *)"cvSet1D(CvArr arr, int idx0, CvScalar value)"},
{ (char *)"cvSet2D", _wrap_cvSet2D, METH_VARARGS, (char *)"cvSet2D(CvArr arr, int idx0, int idx1, CvScalar value)"},
{ (char *)"cvSet3D", _wrap_cvSet3D, METH_VARARGS, (char *)"cvSet3D(CvArr arr, int idx0, int idx1, int idx2, CvScalar value)"},
{ (char *)"cvSetND", _wrap_cvSetND, METH_VARARGS, (char *)"cvSetND(CvArr arr, int idx, CvScalar value)"},
{ (char *)"cvSetReal1D", _wrap_cvSetReal1D, METH_VARARGS, (char *)"cvSetReal1D(CvArr arr, int idx0, double value)"},
{ (char *)"cvSetReal2D", _wrap_cvSetReal2D, METH_VARARGS, (char *)"cvSetReal2D(CvArr arr, int idx0, int idx1, double value)"},
{ (char *)"cvSetReal3D", _wrap_cvSetReal3D, METH_VARARGS, (char *)"cvSetReal3D(CvArr arr, int idx0, int idx1, int idx2, double value)"},
{ (char *)"cvSetRealND", _wrap_cvSetRealND, METH_VARARGS, (char *)"cvSetRealND(CvArr arr, int idx, double value)"},
{ (char *)"cvClearND", _wrap_cvClearND, METH_VARARGS, (char *)"cvClearND(CvArr arr, int idx)"},
{ (char *)"cvGetMat", _wrap_cvGetMat, METH_VARARGS, (char *)"cvGetMat(CvArr arr, CvMat header, int coi=None, int allowND=0) -> CvMat"},
{ (char *)"cvReshapeMatND", _wrap_cvReshapeMatND, METH_VARARGS, (char *)"\n"
"cvReshapeMatND(CvArr arr, int sizeof_header, CvArr header, int new_cn, \n"
" int new_dims, int new_sizes) -> CvArr\n"
""},
{ (char *)"cvReshape", _wrap_cvReshape, METH_VARARGS, (char *)"cvReshape(CvArr arr, CvMat header, int new_cn, int new_rows=0) -> CvMat"},
{ (char *)"cvRepeat", _wrap_cvRepeat, METH_VARARGS, (char *)"cvRepeat(CvArr src, CvArr dst)"},
{ (char *)"cvCreateData", _wrap_cvCreateData, METH_VARARGS, (char *)"cvCreateData(CvArr arr)"},
{ (char *)"cvReleaseData", _wrap_cvReleaseData, METH_VARARGS, (char *)"cvReleaseData(CvArr arr)"},
{ (char *)"cvSetData", _wrap_cvSetData, METH_VARARGS, (char *)"cvSetData(CvArr arr, void data, int step)"},
{ (char *)"cvGetRawData", _wrap_cvGetRawData, METH_VARARGS, (char *)"cvGetRawData(CvArr arr, uchar data, int step=None, CvSize roi_size=None)"},
{ (char *)"cvGetSize", _wrap_cvGetSize, METH_VARARGS, (char *)"cvGetSize(CvArr arr) -> CvSize"},
{ (char *)"cvCopy", _wrap_cvCopy, METH_VARARGS, (char *)"cvCopy(CvArr src, CvArr dst, CvArr mask=None)"},
{ (char *)"cvSet", _wrap_cvSet, METH_VARARGS, (char *)"cvSet(CvArr arr, CvScalar value, CvArr mask=None)"},
{ (char *)"cvSetZero", _wrap_cvSetZero, METH_VARARGS, (char *)"cvSetZero(CvArr arr)"},
{ (char *)"cvSplit", _wrap_cvSplit, METH_VARARGS, (char *)"cvSplit(CvArr src, CvArr dst0, CvArr dst1, CvArr dst2, CvArr dst3)"},
{ (char *)"cvMerge", _wrap_cvMerge, METH_VARARGS, (char *)"cvMerge(CvArr src0, CvArr src1, CvArr src2, CvArr src3, CvArr dst)"},
{ (char *)"cvMixChannels", _wrap_cvMixChannels, METH_VARARGS, (char *)"\n"
"cvMixChannels(CvArr src, int src_count, CvArr dst, int dst_count, \n"
" int from_to, int pair_count)\n"
""},
{ (char *)"cvConvertScale", _wrap_cvConvertScale, METH_VARARGS, (char *)"cvConvertScale(CvArr src, CvArr dst, double scale=1, double shift=0)"},
{ (char *)"cvConvertScaleAbs", _wrap_cvConvertScaleAbs, METH_VARARGS, (char *)"cvConvertScaleAbs(CvArr src, CvArr dst, double scale=1, double shift=0)"},
{ (char *)"cvCheckTermCriteria", _wrap_cvCheckTermCriteria, METH_VARARGS, (char *)"cvCheckTermCriteria(CvTermCriteria criteria, double default_eps, int default_max_iters) -> CvTermCriteria"},
{ (char *)"cvAdd", _wrap_cvAdd, METH_VARARGS, (char *)"cvAdd(CvArr src1, CvArr src2, CvArr dst, CvArr mask=None)"},
{ (char *)"cvAddS", _wrap_cvAddS, METH_VARARGS, (char *)"cvAddS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvSub", _wrap_cvSub, METH_VARARGS, (char *)"cvSub(CvArr src1, CvArr src2, CvArr dst, CvArr mask=None)"},
{ (char *)"cvSubS", _wrap_cvSubS, METH_VARARGS, (char *)"cvSubS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvSubRS", _wrap_cvSubRS, METH_VARARGS, (char *)"cvSubRS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvMul", _wrap_cvMul, METH_VARARGS, (char *)"cvMul(CvArr src1, CvArr src2, CvArr dst, double scale=1)"},
{ (char *)"cvDiv", _wrap_cvDiv, METH_VARARGS, (char *)"cvDiv(CvArr src1, CvArr src2, CvArr dst, double scale=1)"},
{ (char *)"cvScaleAdd", _wrap_cvScaleAdd, METH_VARARGS, (char *)"cvScaleAdd(CvArr src1, CvScalar scale, CvArr src2, CvArr dst)"},
{ (char *)"cvAddWeighted", _wrap_cvAddWeighted, METH_VARARGS, (char *)"\n"
"cvAddWeighted(CvArr src1, double alpha, CvArr src2, double beta, \n"
" double gamma, CvArr dst)\n"
""},
{ (char *)"cvDotProduct", _wrap_cvDotProduct, METH_VARARGS, (char *)"cvDotProduct(CvArr src1, CvArr src2) -> double"},
{ (char *)"cvAnd", _wrap_cvAnd, METH_VARARGS, (char *)"cvAnd(CvArr src1, CvArr src2, CvArr dst, CvArr mask=None)"},
{ (char *)"cvAndS", _wrap_cvAndS, METH_VARARGS, (char *)"cvAndS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvOr", _wrap_cvOr, METH_VARARGS, (char *)"cvOr(CvArr src1, CvArr src2, CvArr dst, CvArr mask=None)"},
{ (char *)"cvOrS", _wrap_cvOrS, METH_VARARGS, (char *)"cvOrS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvXor", _wrap_cvXor, METH_VARARGS, (char *)"cvXor(CvArr src1, CvArr src2, CvArr dst, CvArr mask=None)"},
{ (char *)"cvXorS", _wrap_cvXorS, METH_VARARGS, (char *)"cvXorS(CvArr src, CvScalar value, CvArr dst, CvArr mask=None)"},
{ (char *)"cvNot", _wrap_cvNot, METH_VARARGS, (char *)"cvNot(CvArr src, CvArr dst)"},
{ (char *)"cvInRange", _wrap_cvInRange, METH_VARARGS, (char *)"cvInRange(CvArr src, CvArr lower, CvArr upper, CvArr dst)"},
{ (char *)"cvInRangeS", _wrap_cvInRangeS, METH_VARARGS, (char *)"cvInRangeS(CvArr src, CvScalar lower, CvScalar upper, CvArr dst)"},
{ (char *)"cvCmp", _wrap_cvCmp, METH_VARARGS, (char *)"cvCmp(CvArr src1, CvArr src2, CvArr dst, int cmp_op)"},
{ (char *)"cvCmpS", _wrap_cvCmpS, METH_VARARGS, (char *)"cvCmpS(CvArr src, double value, CvArr dst, int cmp_op)"},
{ (char *)"cvMin", _wrap_cvMin, METH_VARARGS, (char *)"cvMin(CvArr src1, CvArr src2, CvArr dst)"},
{ (char *)"cvMax", _wrap_cvMax, METH_VARARGS, (char *)"cvMax(CvArr src1, CvArr src2, CvArr dst)"},
{ (char *)"cvMinS", _wrap_cvMinS, METH_VARARGS, (char *)"cvMinS(CvArr src, double value, CvArr dst)"},
{ (char *)"cvMaxS", _wrap_cvMaxS, METH_VARARGS, (char *)"cvMaxS(CvArr src, double value, CvArr dst)"},
{ (char *)"cvAbsDiff", _wrap_cvAbsDiff, METH_VARARGS, (char *)"cvAbsDiff(CvArr src1, CvArr src2, CvArr dst)"},
{ (char *)"cvAbsDiffS", _wrap_cvAbsDiffS, METH_VARARGS, (char *)"cvAbsDiffS(CvArr src, CvArr dst, CvScalar value)"},
{ (char *)"cvCartToPolar", _wrap_cvCartToPolar, METH_VARARGS, (char *)"\n"
"cvCartToPolar(CvArr x, CvArr y, CvArr magnitude, CvArr angle=None, \n"
" int angle_in_degrees=0)\n"
""},
{ (char *)"cvPolarToCart", _wrap_cvPolarToCart, METH_VARARGS, (char *)"cvPolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y, int angle_in_degrees=0)"},
{ (char *)"cvPow", _wrap_cvPow, METH_VARARGS, (char *)"cvPow(CvArr src, CvArr dst, double power)"},
{ (char *)"cvExp", _wrap_cvExp, METH_VARARGS, (char *)"cvExp(CvArr src, CvArr dst)"},
{ (char *)"cvLog", _wrap_cvLog, METH_VARARGS, (char *)"cvLog(CvArr src, CvArr dst)"},
{ (char *)"cvFastArctan", _wrap_cvFastArctan, METH_VARARGS, (char *)"cvFastArctan(float y, float x) -> float"},
{ (char *)"cvCbrt", _wrap_cvCbrt, METH_VARARGS, (char *)"cvCbrt(float value) -> float"},
{ (char *)"cvCheckArr", _wrap_cvCheckArr, METH_VARARGS, (char *)"cvCheckArr(CvArr arr, int flags=0, double min_val=0, double max_val=0) -> int"},
{ (char *)"cvRandArr", _wrap_cvRandArr, METH_VARARGS, (char *)"\n"
"cvRandArr(CvRNG rng, CvArr arr, int dist_type, CvScalar param1, \n"
" CvScalar param2)\n"
""},
{ (char *)"cvRandShuffle", _wrap_cvRandShuffle, METH_VARARGS, (char *)"cvRandShuffle(CvArr mat, CvRNG rng, double iter_factor=1.)"},
{ (char *)"cvSort", _wrap_cvSort, METH_VARARGS, (char *)"cvSort(CvArr src, CvArr dst=None, CvArr idxmat=None, int flags=0)"},
{ (char *)"cvSolveCubic", _wrap_cvSolveCubic, METH_VARARGS, (char *)"cvSolveCubic(CvMat coeffs, CvMat roots) -> int"},
{ (char *)"cvSolvePoly", _wrap_cvSolvePoly, METH_VARARGS, (char *)"cvSolvePoly(CvMat coeffs, CvMat roots, int maxiter=0, int fig=0)"},
{ (char *)"cvCrossProduct", _wrap_cvCrossProduct, METH_VARARGS, (char *)"cvCrossProduct(CvArr src1, CvArr src2, CvArr dst)"},
{ (char *)"cvGEMM", _wrap_cvGEMM, METH_VARARGS, (char *)"\n"
"cvGEMM(CvArr src1, CvArr src2, double alpha, CvArr src3, double beta, \n"
" CvArr dst, int tABC=0)\n"
""},
{ (char *)"cvTransform", _wrap_cvTransform, METH_VARARGS, (char *)"cvTransform(CvArr src, CvArr dst, CvMat transmat, CvMat shiftvec=None)"},
{ (char *)"cvPerspectiveTransform", _wrap_cvPerspectiveTransform, METH_VARARGS, (char *)"cvPerspectiveTransform(CvArr src, CvArr dst, CvMat mat)"},
{ (char *)"cvMulTransposed", _wrap_cvMulTransposed, METH_VARARGS, (char *)"\n"
"cvMulTransposed(CvArr src, CvArr dst, int order, CvArr delta=None, \n"
" double scale=1.)\n"
""},
{ (char *)"cvTranspose", _wrap_cvTranspose, METH_VARARGS, (char *)"cvTranspose(CvArr src, CvArr dst)"},
{ (char *)"cvCompleteSymm", _wrap_cvCompleteSymm, METH_VARARGS, (char *)"cvCompleteSymm(CvMat matrix, int LtoR=0)"},
{ (char *)"cvFlip", _wrap_cvFlip, METH_VARARGS, (char *)"cvFlip(CvArr src, CvArr dst=None, int flip_mode=0)"},
{ (char *)"cvSVD", _wrap_cvSVD, METH_VARARGS, (char *)"cvSVD(CvArr A, CvArr W, CvArr U=None, CvArr V=None, int flags=0)"},
{ (char *)"cvSVBkSb", _wrap_cvSVBkSb, METH_VARARGS, (char *)"cvSVBkSb(CvArr W, CvArr U, CvArr V, CvArr B, CvArr X, int flags)"},
{ (char *)"cvInvert", _wrap_cvInvert, METH_VARARGS, (char *)"cvInvert(CvArr src, CvArr dst, int method=0) -> double"},
{ (char *)"cvSolve", _wrap_cvSolve, METH_VARARGS, (char *)"cvSolve(CvArr src1, CvArr src2, CvArr dst, int method=0) -> int"},
{ (char *)"cvDet", _wrap_cvDet, METH_VARARGS, (char *)"cvDet(CvArr mat) -> double"},
{ (char *)"cvTrace", _wrap_cvTrace, METH_VARARGS, (char *)"cvTrace(CvArr mat) -> CvScalar"},
{ (char *)"cvEigenVV", _wrap_cvEigenVV, METH_VARARGS, (char *)"cvEigenVV(CvArr mat, CvArr evects, CvArr evals, double eps=0)"},
{ (char *)"cvSetIdentity", _wrap_cvSetIdentity, METH_VARARGS, (char *)"cvSetIdentity(CvArr mat, CvScalar value=cvRealScalar(1))"},
{ (char *)"cvRange", _wrap_cvRange, METH_VARARGS, (char *)"cvRange(CvArr mat, double start, double end) -> CvArr"},
{ (char *)"cvCalcCovarMatrix", _wrap_cvCalcCovarMatrix, METH_VARARGS, (char *)"cvCalcCovarMatrix(CvArr vects, int count, CvArr cov_mat, CvArr avg, int flags)"},
{ (char *)"cvCalcPCA", _wrap_cvCalcPCA, METH_VARARGS, (char *)"\n"
"cvCalcPCA(CvArr data, CvArr mean, CvArr eigenvals, CvArr eigenvects, \n"
" int flags)\n"
""},
{ (char *)"cvProjectPCA", _wrap_cvProjectPCA, METH_VARARGS, (char *)"cvProjectPCA(CvArr data, CvArr mean, CvArr eigenvects, CvArr result)"},
{ (char *)"cvBackProjectPCA", _wrap_cvBackProjectPCA, METH_VARARGS, (char *)"cvBackProjectPCA(CvArr proj, CvArr mean, CvArr eigenvects, CvArr result)"},
{ (char *)"cvMahalanobis", _wrap_cvMahalanobis, METH_VARARGS, (char *)"cvMahalanobis(CvArr vec1, CvArr vec2, CvArr mat) -> double"},
{ (char *)"cvSum", _wrap_cvSum, METH_VARARGS, (char *)"cvSum(CvArr arr) -> CvScalar"},
{ (char *)"cvCountNonZero", _wrap_cvCountNonZero, METH_VARARGS, (char *)"cvCountNonZero(CvArr arr) -> int"},
{ (char *)"cvAvg", _wrap_cvAvg, METH_VARARGS, (char *)"cvAvg(CvArr arr, CvArr mask=None) -> CvScalar"},
{ (char *)"cvAvgSdv", _wrap_cvAvgSdv, METH_VARARGS, (char *)"cvAvgSdv(CvArr arr, CvScalar mean, CvScalar std_dev, CvArr mask=None)"},
{ (char *)"cvMinMaxLoc", _wrap_cvMinMaxLoc, METH_VARARGS, (char *)"\n"
"cvMinMaxLoc(CvArr arr, double min_val, double max_val, CvPoint min_loc=None, \n"
" CvPoint max_loc=None, CvArr mask=None)\n"
""},
{ (char *)"cvNorm", _wrap_cvNorm, METH_VARARGS, (char *)"cvNorm(CvArr arr1, CvArr arr2=None, int norm_type=4, CvArr mask=None) -> double"},
{ (char *)"cvNormalize", _wrap_cvNormalize, METH_VARARGS, (char *)"\n"
"cvNormalize(CvArr src, CvArr dst, double a=1., double b=0., int norm_type=4, \n"
" CvArr mask=None)\n"
""},
{ (char *)"cvReduce", _wrap_cvReduce, METH_VARARGS, (char *)"cvReduce(CvArr src, CvArr dst, int dim=-1, int op=0)"},
{ (char *)"cvDFT", _wrap_cvDFT, METH_VARARGS, (char *)"cvDFT(CvArr src, CvArr dst, int flags, int nonzero_rows=0)"},
{ (char *)"cvMulSpectrums", _wrap_cvMulSpectrums, METH_VARARGS, (char *)"cvMulSpectrums(CvArr src1, CvArr src2, CvArr dst, int flags)"},
{ (char *)"cvGetOptimalDFTSize", _wrap_cvGetOptimalDFTSize, METH_VARARGS, (char *)"cvGetOptimalDFTSize(int size0) -> int"},
{ (char *)"cvDCT", _wrap_cvDCT, METH_VARARGS, (char *)"cvDCT(CvArr src, CvArr dst, int flags)"},
{ (char *)"cvSliceLength", _wrap_cvSliceLength, METH_VARARGS, (char *)"cvSliceLength(CvSlice slice, CvSeq seq) -> int"},
{ (char *)"cvCreateMemStorage", _wrap_cvCreateMemStorage, METH_VARARGS, (char *)"cvCreateMemStorage(int block_size=0) -> CvMemStorage"},
{ (char *)"cvCreateChildMemStorage", _wrap_cvCreateChildMemStorage, METH_VARARGS, (char *)"cvCreateChildMemStorage(CvMemStorage parent) -> CvMemStorage"},
{ (char *)"cvClearMemStorage", _wrap_cvClearMemStorage, METH_VARARGS, (char *)"cvClearMemStorage(CvMemStorage storage)"},
{ (char *)"cvSaveMemStoragePos", _wrap_cvSaveMemStoragePos, METH_VARARGS, (char *)"cvSaveMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)"},
{ (char *)"cvRestoreMemStoragePos", _wrap_cvRestoreMemStoragePos, METH_VARARGS, (char *)"cvRestoreMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)"},
{ (char *)"cvMemStorageAlloc", _wrap_cvMemStorageAlloc, METH_VARARGS, (char *)"cvMemStorageAlloc(CvMemStorage storage, size_t size) -> void"},
{ (char *)"cvMemStorageAllocString", _wrap_cvMemStorageAllocString, METH_VARARGS, (char *)"cvMemStorageAllocString(CvMemStorage storage, char ptr, int len=-1) -> CvString"},
{ (char *)"cvCreateSeq", _wrap_cvCreateSeq, METH_VARARGS, (char *)"cvCreateSeq(int seq_flags, int header_size, int elem_size, CvMemStorage storage) -> CvSeq"},
{ (char *)"cvSetSeqBlockSize", _wrap_cvSetSeqBlockSize, METH_VARARGS, (char *)"cvSetSeqBlockSize(CvSeq seq, int delta_elems)"},
{ (char *)"cvSeqPush", _wrap_cvSeqPush, METH_VARARGS, (char *)"cvSeqPush(CvSeq seq, void element=None) -> schar"},
{ (char *)"cvSeqPushFront", _wrap_cvSeqPushFront, METH_VARARGS, (char *)"cvSeqPushFront(CvSeq seq, void element=None) -> schar"},
{ (char *)"cvSeqPop", _wrap_cvSeqPop, METH_VARARGS, (char *)"cvSeqPop(CvSeq seq, void element=None)"},
{ (char *)"cvSeqPopFront", _wrap_cvSeqPopFront, METH_VARARGS, (char *)"cvSeqPopFront(CvSeq seq, void element=None)"},
{ (char *)"cvSeqPushMulti", _wrap_cvSeqPushMulti, METH_VARARGS, (char *)"cvSeqPushMulti(CvSeq seq, void elements, int count, int in_front=0)"},
{ (char *)"cvSeqPopMulti", _wrap_cvSeqPopMulti, METH_VARARGS, (char *)"cvSeqPopMulti(CvSeq seq, void elements, int count, int in_front=0)"},
{ (char *)"cvSeqInsert", _wrap_cvSeqInsert, METH_VARARGS, (char *)"cvSeqInsert(CvSeq seq, int before_index, void element=None) -> schar"},
{ (char *)"cvSeqRemove", _wrap_cvSeqRemove, METH_VARARGS, (char *)"cvSeqRemove(CvSeq seq, int index)"},
{ (char *)"cvClearSeq", _wrap_cvClearSeq, METH_VARARGS, (char *)"cvClearSeq(CvSeq seq)"},
{ (char *)"cvGetSeqElem", _wrap_cvGetSeqElem, METH_VARARGS, (char *)"cvGetSeqElem(CvSeq seq, int index) -> schar"},
{ (char *)"cvSeqElemIdx", _wrap_cvSeqElemIdx, METH_VARARGS, (char *)"cvSeqElemIdx(CvSeq seq, void element, CvSeqBlock block=None) -> int"},
{ (char *)"cvStartAppendToSeq", _wrap_cvStartAppendToSeq, METH_VARARGS, (char *)"cvStartAppendToSeq(CvSeq seq, CvSeqWriter writer)"},
{ (char *)"cvStartWriteSeq", _wrap_cvStartWriteSeq, METH_VARARGS, (char *)"\n"
"cvStartWriteSeq(int seq_flags, int header_size, int elem_size, CvMemStorage storage, \n"
" CvSeqWriter writer)\n"
""},
{ (char *)"cvEndWriteSeq", _wrap_cvEndWriteSeq, METH_VARARGS, (char *)"cvEndWriteSeq(CvSeqWriter writer) -> CvSeq"},
{ (char *)"cvFlushSeqWriter", _wrap_cvFlushSeqWriter, METH_VARARGS, (char *)"cvFlushSeqWriter(CvSeqWriter writer)"},
{ (char *)"cvStartReadSeq", _wrap_cvStartReadSeq, METH_VARARGS, (char *)"cvStartReadSeq(CvSeq seq, CvSeqReader reader, int reverse=0)"},
{ (char *)"cvGetSeqReaderPos", _wrap_cvGetSeqReaderPos, METH_VARARGS, (char *)"cvGetSeqReaderPos(CvSeqReader reader) -> int"},
{ (char *)"cvSetSeqReaderPos", _wrap_cvSetSeqReaderPos, METH_VARARGS, (char *)"cvSetSeqReaderPos(CvSeqReader reader, int index, int is_relative=0)"},
{ (char *)"cvMakeSeqHeaderForArray", _wrap_cvMakeSeqHeaderForArray, METH_VARARGS, (char *)"\n"
"cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, void elements, \n"
" int total, CvSeq seq, CvSeqBlock block) -> CvSeq\n"
""},
{ (char *)"cvSeqSlice", _wrap_cvSeqSlice, METH_VARARGS, (char *)"\n"
"cvSeqSlice(CvSeq seq, CvSlice slice, CvMemStorage storage=None, \n"
" int copy_data=0) -> CvSeq\n"
""},
{ (char *)"cvCloneSeq", _wrap_cvCloneSeq, METH_VARARGS, (char *)"cvCloneSeq(CvSeq seq, CvMemStorage storage=None) -> CvSeq"},
{ (char *)"cvSeqRemoveSlice", _wrap_cvSeqRemoveSlice, METH_VARARGS, (char *)"cvSeqRemoveSlice(CvSeq seq, CvSlice slice)"},
{ (char *)"cvSeqInsertSlice", _wrap_cvSeqInsertSlice, METH_VARARGS, (char *)"cvSeqInsertSlice(CvSeq seq, int before_index, CvArr from_arr)"},
{ (char *)"cvSeqSort", _wrap_cvSeqSort, METH_VARARGS, (char *)"cvSeqSort(CvSeq seq, CvCmpFunc func, void userdata=None)"},
{ (char *)"cvSeqSearch", _wrap_cvSeqSearch, METH_VARARGS, (char *)"\n"
"cvSeqSearch(CvSeq seq, void elem, CvCmpFunc func, int is_sorted, \n"
" int elem_idx, void userdata=None) -> schar\n"
""},
{ (char *)"cvSeqInvert", _wrap_cvSeqInvert, METH_VARARGS, (char *)"cvSeqInvert(CvSeq seq)"},
{ (char *)"cvSeqPartition", _wrap_cvSeqPartition, METH_VARARGS, (char *)"\n"
"cvSeqPartition(CvSeq seq, CvMemStorage storage, CvSeq labels, CvCmpFunc is_equal, \n"
" void userdata) -> int\n"
""},
{ (char *)"cvChangeSeqBlock", _wrap_cvChangeSeqBlock, METH_VARARGS, (char *)"cvChangeSeqBlock(void reader, int direction)"},
{ (char *)"cvCreateSeqBlock", _wrap_cvCreateSeqBlock, METH_VARARGS, (char *)"cvCreateSeqBlock(CvSeqWriter writer)"},
{ (char *)"cvCreateSet", _wrap_cvCreateSet, METH_VARARGS, (char *)"cvCreateSet(int set_flags, int header_size, int elem_size, CvMemStorage storage) -> CvSet"},
{ (char *)"cvSetAdd", _wrap_cvSetAdd, METH_VARARGS, (char *)"cvSetAdd(CvSet set_header, CvSetElem elem=None, CvSetElem inserted_elem=None) -> int"},
{ (char *)"cvSetNew", _wrap_cvSetNew, METH_VARARGS, (char *)"cvSetNew(CvSet set_header) -> CvSetElem"},
{ (char *)"cvSetRemoveByPtr", _wrap_cvSetRemoveByPtr, METH_VARARGS, (char *)"cvSetRemoveByPtr(CvSet set_header, void elem)"},
{ (char *)"cvSetRemove", _wrap_cvSetRemove, METH_VARARGS, (char *)"cvSetRemove(CvSet set_header, int index)"},
{ (char *)"cvGetSetElem", _wrap_cvGetSetElem, METH_VARARGS, (char *)"cvGetSetElem(CvSet set_header, int index) -> CvSetElem"},
{ (char *)"cvClearSet", _wrap_cvClearSet, METH_VARARGS, (char *)"cvClearSet(CvSet set_header)"},
{ (char *)"cvCreateGraph", _wrap_cvCreateGraph, METH_VARARGS, (char *)"\n"
"cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size, \n"
" CvMemStorage storage) -> CvGraph\n"
""},
{ (char *)"cvGraphAddVtx", _wrap_cvGraphAddVtx, METH_VARARGS, (char *)"cvGraphAddVtx(CvGraph graph, CvGraphVtx vtx=None, CvGraphVtx inserted_vtx=None) -> int"},
{ (char *)"cvGraphRemoveVtx", _wrap_cvGraphRemoveVtx, METH_VARARGS, (char *)"cvGraphRemoveVtx(CvGraph graph, int index) -> int"},
{ (char *)"cvGraphRemoveVtxByPtr", _wrap_cvGraphRemoveVtxByPtr, METH_VARARGS, (char *)"cvGraphRemoveVtxByPtr(CvGraph graph, CvGraphVtx vtx) -> int"},
{ (char *)"cvGraphAddEdge", _wrap_cvGraphAddEdge, METH_VARARGS, (char *)"\n"
"cvGraphAddEdge(CvGraph graph, int start_idx, int end_idx, CvGraphEdge edge=None, \n"
" CvGraphEdge inserted_edge=None) -> int\n"
""},
{ (char *)"cvGraphAddEdgeByPtr", _wrap_cvGraphAddEdgeByPtr, METH_VARARGS, (char *)"\n"
"cvGraphAddEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx, \n"
" CvGraphEdge edge=None, CvGraphEdge inserted_edge=None) -> int\n"
""},
{ (char *)"cvGraphRemoveEdge", _wrap_cvGraphRemoveEdge, METH_VARARGS, (char *)"cvGraphRemoveEdge(CvGraph graph, int start_idx, int end_idx)"},
{ (char *)"cvGraphRemoveEdgeByPtr", _wrap_cvGraphRemoveEdgeByPtr, METH_VARARGS, (char *)"cvGraphRemoveEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx)"},
{ (char *)"cvFindGraphEdge", _wrap_cvFindGraphEdge, METH_VARARGS, (char *)"cvFindGraphEdge(CvGraph graph, int start_idx, int end_idx) -> CvGraphEdge"},
{ (char *)"cvFindGraphEdgeByPtr", _wrap_cvFindGraphEdgeByPtr, METH_VARARGS, (char *)"cvFindGraphEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx) -> CvGraphEdge"},
{ (char *)"cvClearGraph", _wrap_cvClearGraph, METH_VARARGS, (char *)"cvClearGraph(CvGraph graph)"},
{ (char *)"cvGraphVtxDegree", _wrap_cvGraphVtxDegree, METH_VARARGS, (char *)"cvGraphVtxDegree(CvGraph graph, int vtx_idx) -> int"},
{ (char *)"cvGraphVtxDegreeByPtr", _wrap_cvGraphVtxDegreeByPtr, METH_VARARGS, (char *)"cvGraphVtxDegreeByPtr(CvGraph graph, CvGraphVtx vtx) -> int"},
{ (char *)"CvGraphScanner_vtx_set", _wrap_CvGraphScanner_vtx_set, METH_VARARGS, (char *)"CvGraphScanner_vtx_set(CvGraphScanner self, CvGraphVtx vtx)"},
{ (char *)"CvGraphScanner_vtx_get", _wrap_CvGraphScanner_vtx_get, METH_VARARGS, (char *)"CvGraphScanner_vtx_get(CvGraphScanner self) -> CvGraphVtx"},
{ (char *)"CvGraphScanner_dst_set", _wrap_CvGraphScanner_dst_set, METH_VARARGS, (char *)"CvGraphScanner_dst_set(CvGraphScanner self, CvGraphVtx dst)"},
{ (char *)"CvGraphScanner_dst_get", _wrap_CvGraphScanner_dst_get, METH_VARARGS, (char *)"CvGraphScanner_dst_get(CvGraphScanner self) -> CvGraphVtx"},
{ (char *)"CvGraphScanner_edge_set", _wrap_CvGraphScanner_edge_set, METH_VARARGS, (char *)"CvGraphScanner_edge_set(CvGraphScanner self, CvGraphEdge edge)"},
{ (char *)"CvGraphScanner_edge_get", _wrap_CvGraphScanner_edge_get, METH_VARARGS, (char *)"CvGraphScanner_edge_get(CvGraphScanner self) -> CvGraphEdge"},
{ (char *)"CvGraphScanner_graph_set", _wrap_CvGraphScanner_graph_set, METH_VARARGS, (char *)"CvGraphScanner_graph_set(CvGraphScanner self, CvGraph graph)"},
{ (char *)"CvGraphScanner_graph_get", _wrap_CvGraphScanner_graph_get, METH_VARARGS, (char *)"CvGraphScanner_graph_get(CvGraphScanner self) -> CvGraph"},
{ (char *)"CvGraphScanner_stack_set", _wrap_CvGraphScanner_stack_set, METH_VARARGS, (char *)"CvGraphScanner_stack_set(CvGraphScanner self, CvSeq stack)"},
{ (char *)"CvGraphScanner_stack_get", _wrap_CvGraphScanner_stack_get, METH_VARARGS, (char *)"CvGraphScanner_stack_get(CvGraphScanner self) -> CvSeq"},
{ (char *)"CvGraphScanner_index_set", _wrap_CvGraphScanner_index_set, METH_VARARGS, (char *)"CvGraphScanner_index_set(CvGraphScanner self, int index)"},
{ (char *)"CvGraphScanner_index_get", _wrap_CvGraphScanner_index_get, METH_VARARGS, (char *)"CvGraphScanner_index_get(CvGraphScanner self) -> int"},
{ (char *)"CvGraphScanner_mask_set", _wrap_CvGraphScanner_mask_set, METH_VARARGS, (char *)"CvGraphScanner_mask_set(CvGraphScanner self, int mask)"},
{ (char *)"CvGraphScanner_mask_get", _wrap_CvGraphScanner_mask_get, METH_VARARGS, (char *)"CvGraphScanner_mask_get(CvGraphScanner self) -> int"},
{ (char *)"delete_CvGraphScanner", _wrap_delete_CvGraphScanner, METH_VARARGS, (char *)"delete_CvGraphScanner(CvGraphScanner self)"},
{ (char *)"CvGraphScanner_swigregister", CvGraphScanner_swigregister, METH_VARARGS, NULL},
{ (char *)"cvCreateGraphScanner", _wrap_cvCreateGraphScanner, METH_VARARGS, (char *)"cvCreateGraphScanner(CvGraph graph, CvGraphVtx vtx=None, int mask=-1) -> CvGraphScanner"},
{ (char *)"cvNextGraphItem", _wrap_cvNextGraphItem, METH_VARARGS, (char *)"cvNextGraphItem(CvGraphScanner scanner) -> int"},
{ (char *)"cvCloneGraph", _wrap_cvCloneGraph, METH_VARARGS, (char *)"cvCloneGraph(CvGraph graph, CvMemStorage storage) -> CvGraph"},
{ (char *)"cvLine", _wrap_cvLine, METH_VARARGS, (char *)"\n"
"cvLine(CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, \n"
" int thickness=1, int line_type=8, int shift=0)\n"
""},
{ (char *)"cvRectangle", _wrap_cvRectangle, METH_VARARGS, (char *)"\n"
"cvRectangle(CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, \n"
" int thickness=1, int line_type=8, int shift=0)\n"
""},
{ (char *)"cvCircle", _wrap_cvCircle, METH_VARARGS, (char *)"\n"
"cvCircle(CvArr img, CvPoint center, int radius, CvScalar color, \n"
" int thickness=1, int line_type=8, int shift=0)\n"
""},
{ (char *)"cvEllipse", _wrap_cvEllipse, METH_VARARGS, (char *)"\n"
"cvEllipse(CvArr img, CvPoint center, CvSize axes, double angle, \n"
" double start_angle, double end_angle, CvScalar color, \n"
" int thickness=1, int line_type=8, \n"
" int shift=0)\n"
""},
{ (char *)"cvEllipseBox", _wrap_cvEllipseBox, METH_VARARGS, (char *)"\n"
"cvEllipseBox(CvArr img, CvBox2D box, CvScalar color, int thickness=1, \n"
" int line_type=8, int shift=0)\n"
""},
{ (char *)"cvFillConvexPoly", _wrap_cvFillConvexPoly, METH_VARARGS, (char *)"\n"
"cvFillConvexPoly(CvArr img, CvPoint pts, CvScalar color, int line_type=8, \n"
" int shift=0)\n"
""},
{ (char *)"cvFillPoly", _wrap_cvFillPoly, METH_VARARGS, (char *)"\n"
"cvFillPoly(CvArr img, CvPoint pts, CvScalar color, int line_type=8, \n"
" int shift=0)\n"
""},
{ (char *)"cvPolyLine", _wrap_cvPolyLine, METH_VARARGS, (char *)"\n"
"cvPolyLine(CvArr img, CvPoint pts, int is_closed, CvScalar color, \n"
" int thickness=1, int line_type=8, int shift=0)\n"
""},
{ (char *)"cvClipLine", _wrap_cvClipLine, METH_VARARGS, (char *)"cvClipLine(CvSize img_size, CvPoint pt1, CvPoint pt2) -> int"},
{ (char *)"cvInitLineIterator", _wrap_cvInitLineIterator, METH_VARARGS, (char *)"\n"
"cvInitLineIterator(CvArr image, CvPoint pt1, CvPoint pt2, CvLineIterator line_iterator, \n"
" int connectivity=8, int left_to_right=0) -> int\n"
""},
{ (char *)"CvFont_font_face_set", _wrap_CvFont_font_face_set, METH_VARARGS, (char *)"CvFont_font_face_set(CvFont self, int font_face)"},
{ (char *)"CvFont_font_face_get", _wrap_CvFont_font_face_get, METH_VARARGS, (char *)"CvFont_font_face_get(CvFont self) -> int"},
{ (char *)"CvFont_ascii_set", _wrap_CvFont_ascii_set, METH_VARARGS, (char *)"CvFont_ascii_set(CvFont self, int ascii)"},
{ (char *)"CvFont_ascii_get", _wrap_CvFont_ascii_get, METH_VARARGS, (char *)"CvFont_ascii_get(CvFont self) -> int"},
{ (char *)"CvFont_greek_set", _wrap_CvFont_greek_set, METH_VARARGS, (char *)"CvFont_greek_set(CvFont self, int greek)"},
{ (char *)"CvFont_greek_get", _wrap_CvFont_greek_get, METH_VARARGS, (char *)"CvFont_greek_get(CvFont self) -> int"},
{ (char *)"CvFont_cyrillic_set", _wrap_CvFont_cyrillic_set, METH_VARARGS, (char *)"CvFont_cyrillic_set(CvFont self, int cyrillic)"},
{ (char *)"CvFont_cyrillic_get", _wrap_CvFont_cyrillic_get, METH_VARARGS, (char *)"CvFont_cyrillic_get(CvFont self) -> int"},
{ (char *)"CvFont_hscale_set", _wrap_CvFont_hscale_set, METH_VARARGS, (char *)"CvFont_hscale_set(CvFont self, float hscale)"},
{ (char *)"CvFont_hscale_get", _wrap_CvFont_hscale_get, METH_VARARGS, (char *)"CvFont_hscale_get(CvFont self) -> float"},
{ (char *)"CvFont_vscale_set", _wrap_CvFont_vscale_set, METH_VARARGS, (char *)"CvFont_vscale_set(CvFont self, float vscale)"},
{ (char *)"CvFont_vscale_get", _wrap_CvFont_vscale_get, METH_VARARGS, (char *)"CvFont_vscale_get(CvFont self) -> float"},
{ (char *)"CvFont_shear_set", _wrap_CvFont_shear_set, METH_VARARGS, (char *)"CvFont_shear_set(CvFont self, float shear)"},
{ (char *)"CvFont_shear_get", _wrap_CvFont_shear_get, METH_VARARGS, (char *)"CvFont_shear_get(CvFont self) -> float"},
{ (char *)"CvFont_thickness_set", _wrap_CvFont_thickness_set, METH_VARARGS, (char *)"CvFont_thickness_set(CvFont self, int thickness)"},
{ (char *)"CvFont_thickness_get", _wrap_CvFont_thickness_get, METH_VARARGS, (char *)"CvFont_thickness_get(CvFont self) -> int"},
{ (char *)"CvFont_dx_set", _wrap_CvFont_dx_set, METH_VARARGS, (char *)"CvFont_dx_set(CvFont self, float dx)"},
{ (char *)"CvFont_dx_get", _wrap_CvFont_dx_get, METH_VARARGS, (char *)"CvFont_dx_get(CvFont self) -> float"},
{ (char *)"CvFont_line_type_set", _wrap_CvFont_line_type_set, METH_VARARGS, (char *)"CvFont_line_type_set(CvFont self, int line_type)"},
{ (char *)"CvFont_line_type_get", _wrap_CvFont_line_type_get, METH_VARARGS, (char *)"CvFont_line_type_get(CvFont self) -> int"},
{ (char *)"new_CvFont", _wrap_new_CvFont, METH_VARARGS, (char *)"new_CvFont() -> CvFont"},
{ (char *)"delete_CvFont", _wrap_delete_CvFont, METH_VARARGS, (char *)"delete_CvFont(CvFont self)"},
{ (char *)"CvFont_swigregister", CvFont_swigregister, METH_VARARGS, NULL},
{ (char *)"cvInitFont", _wrap_cvInitFont, METH_VARARGS, (char *)"\n"
"cvInitFont(CvFont font, double hscale, double vscale, double shear=0, \n"
" int thickness=1, int line_type=8)\n"
""},
{ (char *)"cvFont", _wrap_cvFont, METH_VARARGS, (char *)"cvFont(double scale, int thickness=1) -> CvFont"},
{ (char *)"cvPutText", _wrap_cvPutText, METH_VARARGS, (char *)"cvPutText(CvArr img, char text, CvPoint org, CvFont font, CvScalar color)"},
{ (char *)"cvGetTextSize", _wrap_cvGetTextSize, METH_VARARGS, (char *)"cvGetTextSize(char text_string, CvFont font, CvSize text_size)"},
{ (char *)"cvColorToScalar", _wrap_cvColorToScalar, METH_VARARGS, (char *)"cvColorToScalar(double packed_color, int arrtype) -> CvScalar"},
{ (char *)"cvEllipse2Poly", _wrap_cvEllipse2Poly, METH_VARARGS, (char *)"\n"
"cvEllipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start, \n"
" int arc_end, CvPoint pts, int delta) -> int\n"
""},
{ (char *)"cvDrawContours", _wrap_cvDrawContours, METH_VARARGS, (char *)"\n"
"cvDrawContours(CvArr img, CvSeq contour, CvScalar external_color, \n"
" CvScalar hole_color, int max_level, int thickness=1, \n"
" int line_type=8, CvPoint offset=cvPoint(0,0))\n"
""},
{ (char *)"cvLUT", _wrap_cvLUT, METH_VARARGS, (char *)"cvLUT(CvArr src, CvArr dst, CvArr lut)"},
{ (char *)"CvTreeNodeIterator_node_set", _wrap_CvTreeNodeIterator_node_set, METH_VARARGS, (char *)"CvTreeNodeIterator_node_set(CvTreeNodeIterator self, void node)"},
{ (char *)"CvTreeNodeIterator_node_get", _wrap_CvTreeNodeIterator_node_get, METH_VARARGS, (char *)"CvTreeNodeIterator_node_get(CvTreeNodeIterator self) -> void"},
{ (char *)"CvTreeNodeIterator_level_set", _wrap_CvTreeNodeIterator_level_set, METH_VARARGS, (char *)"CvTreeNodeIterator_level_set(CvTreeNodeIterator self, int level)"},
{ (char *)"CvTreeNodeIterator_level_get", _wrap_CvTreeNodeIterator_level_get, METH_VARARGS, (char *)"CvTreeNodeIterator_level_get(CvTreeNodeIterator self) -> int"},
{ (char *)"CvTreeNodeIterator_max_level_set", _wrap_CvTreeNodeIterator_max_level_set, METH_VARARGS, (char *)"CvTreeNodeIterator_max_level_set(CvTreeNodeIterator self, int max_level)"},
{ (char *)"CvTreeNodeIterator_max_level_get", _wrap_CvTreeNodeIterator_max_level_get, METH_VARARGS, (char *)"CvTreeNodeIterator_max_level_get(CvTreeNodeIterator self) -> int"},
{ (char *)"new_CvTreeNodeIterator", _wrap_new_CvTreeNodeIterator, METH_VARARGS, (char *)"new_CvTreeNodeIterator() -> CvTreeNodeIterator"},
{ (char *)"delete_CvTreeNodeIterator", _wrap_delete_CvTreeNodeIterator, METH_VARARGS, (char *)"delete_CvTreeNodeIterator(CvTreeNodeIterator self)"},
{ (char *)"CvTreeNodeIterator_swigregister", CvTreeNodeIterator_swigregister, METH_VARARGS, NULL},
{ (char *)"cvInitTreeNodeIterator", _wrap_cvInitTreeNodeIterator, METH_VARARGS, (char *)"cvInitTreeNodeIterator(CvTreeNodeIterator tree_iterator, void first, int max_level)"},
{ (char *)"cvNextTreeNode", _wrap_cvNextTreeNode, METH_VARARGS, (char *)"cvNextTreeNode(CvTreeNodeIterator tree_iterator) -> void"},
{ (char *)"cvPrevTreeNode", _wrap_cvPrevTreeNode, METH_VARARGS, (char *)"cvPrevTreeNode(CvTreeNodeIterator tree_iterator) -> void"},
{ (char *)"cvInsertNodeIntoTree", _wrap_cvInsertNodeIntoTree, METH_VARARGS, (char *)"cvInsertNodeIntoTree(void node, void parent, void frame)"},
{ (char *)"cvRemoveNodeFromTree", _wrap_cvRemoveNodeFromTree, METH_VARARGS, (char *)"cvRemoveNodeFromTree(void node, void frame)"},
{ (char *)"cvTreeToNodeSeq", _wrap_cvTreeToNodeSeq, METH_VARARGS, (char *)"cvTreeToNodeSeq(void first, int header_size, CvMemStorage storage) -> CvSeq"},
{ (char *)"cvKMeans2", _wrap_cvKMeans2, METH_VARARGS, (char *)"cvKMeans2(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit)"},
{ (char *)"cvRegisterModule", _wrap_cvRegisterModule, METH_VARARGS, (char *)"cvRegisterModule(CvModuleInfo module_info) -> int"},
{ (char *)"cvUseOptimized", _wrap_cvUseOptimized, METH_VARARGS, (char *)"cvUseOptimized(int on_off) -> int"},
{ (char *)"cvGetModuleInfo", _wrap_cvGetModuleInfo, METH_VARARGS, (char *)"cvGetModuleInfo(char module_name, char version, char loaded_addon_plugins)"},
{ (char *)"cvGetErrStatus", _wrap_cvGetErrStatus, METH_VARARGS, (char *)"cvGetErrStatus() -> int"},
{ (char *)"cvSetErrStatus", _wrap_cvSetErrStatus, METH_VARARGS, (char *)"cvSetErrStatus(int status)"},
{ (char *)"cvGetErrMode", _wrap_cvGetErrMode, METH_VARARGS, (char *)"cvGetErrMode() -> int"},
{ (char *)"cvSetErrMode", _wrap_cvSetErrMode, METH_VARARGS, (char *)"cvSetErrMode(int mode) -> int"},
{ (char *)"cvError", _wrap_cvError, METH_VARARGS, (char *)"\n"
"cvError(int status, char func_name, char err_msg, char file_name, \n"
" int line)\n"
""},
{ (char *)"cvErrorStr", _wrap_cvErrorStr, METH_VARARGS, (char *)"cvErrorStr(int status) -> char"},
{ (char *)"cvGetErrInfo", _wrap_cvGetErrInfo, METH_VARARGS, (char *)"\n"
"cvGetErrInfo(char errcode_desc, char description, char filename, \n"
" int line) -> int\n"
""},
{ (char *)"cvErrorFromIppStatus", _wrap_cvErrorFromIppStatus, METH_VARARGS, (char *)"cvErrorFromIppStatus(int ipp_status) -> int"},
{ (char *)"cvRedirectError", _wrap_cvRedirectError, METH_VARARGS, (char *)"\n"
"cvRedirectError(CvErrorCallback error_handler, void userdata=None, \n"
" void prev_userdata=None) -> CvErrorCallback\n"
""},
{ (char *)"cvNulDevReport", _wrap_cvNulDevReport, METH_VARARGS, (char *)"\n"
"cvNulDevReport(int status, char func_name, char err_msg, char file_name, \n"
" int line, void userdata) -> int\n"
""},
{ (char *)"cvStdErrReport", _wrap_cvStdErrReport, METH_VARARGS, (char *)"\n"
"cvStdErrReport(int status, char func_name, char err_msg, char file_name, \n"
" int line, void userdata) -> int\n"
""},
{ (char *)"cvGuiBoxReport", _wrap_cvGuiBoxReport, METH_VARARGS, (char *)"\n"
"cvGuiBoxReport(int status, char func_name, char err_msg, char file_name, \n"
" int line, void userdata) -> int\n"
""},
{ (char *)"cvSetMemoryManager", _wrap_cvSetMemoryManager, METH_VARARGS, (char *)"\n"
"cvSetMemoryManager(CvAllocFunc alloc_func=None, CvFreeFunc free_func=None, \n"
" void userdata=None)\n"
""},
{ (char *)"cvSetIPLAllocators", _wrap_cvSetIPLAllocators, METH_VARARGS, (char *)"\n"
"cvSetIPLAllocators(Cv_iplCreateImageHeader create_header, Cv_iplAllocateImageData allocate_data, \n"
" Cv_iplDeallocate deallocate, \n"
" Cv_iplCreateROI create_roi, Cv_iplCloneImage clone_image)\n"
""},
{ (char *)"cvOpenFileStorage", _wrap_cvOpenFileStorage, METH_VARARGS, (char *)"cvOpenFileStorage(char filename, CvMemStorage memstorage, int flags) -> CvFileStorage"},
{ (char *)"cvAttrValue", _wrap_cvAttrValue, METH_VARARGS, (char *)"cvAttrValue(CvAttrList attr, char attr_name) -> char"},
{ (char *)"cvStartWriteStruct", _wrap_cvStartWriteStruct, METH_VARARGS, (char *)"\n"
"cvStartWriteStruct(CvFileStorage fs, char name, int struct_flags, char type_name=None, \n"
" CvAttrList attributes=cvAttrList())\n"
""},
{ (char *)"cvEndWriteStruct", _wrap_cvEndWriteStruct, METH_VARARGS, (char *)"cvEndWriteStruct(CvFileStorage fs)"},
{ (char *)"cvWriteInt", _wrap_cvWriteInt, METH_VARARGS, (char *)"cvWriteInt(CvFileStorage fs, char name, int value)"},
{ (char *)"cvWriteReal", _wrap_cvWriteReal, METH_VARARGS, (char *)"cvWriteReal(CvFileStorage fs, char name, double value)"},
{ (char *)"cvWriteString", _wrap_cvWriteString, METH_VARARGS, (char *)"cvWriteString(CvFileStorage fs, char name, char str, int quote=0)"},
{ (char *)"cvWriteComment", _wrap_cvWriteComment, METH_VARARGS, (char *)"cvWriteComment(CvFileStorage fs, char comment, int eol_comment)"},
{ (char *)"cvWrite", _wrap_cvWrite, METH_VARARGS, (char *)"cvWrite(CvFileStorage fs, char name, void ptr, CvAttrList attributes=cvAttrList())"},
{ (char *)"cvStartNextStream", _wrap_cvStartNextStream, METH_VARARGS, (char *)"cvStartNextStream(CvFileStorage fs)"},
{ (char *)"cvWriteRawData", _wrap_cvWriteRawData, METH_VARARGS, (char *)"cvWriteRawData(CvFileStorage fs, void src, int len, char dt)"},
{ (char *)"cvGetHashedKey", _wrap_cvGetHashedKey, METH_VARARGS, (char *)"cvGetHashedKey(CvFileStorage fs, char name, int len=-1, int create_missing=0) -> CvStringHashNode"},
{ (char *)"cvGetRootFileNode", _wrap_cvGetRootFileNode, METH_VARARGS, (char *)"cvGetRootFileNode(CvFileStorage fs, int stream_index=0) -> CvFileNode"},
{ (char *)"cvGetFileNode", _wrap_cvGetFileNode, METH_VARARGS, (char *)"\n"
"cvGetFileNode(CvFileStorage fs, CvFileNode map, CvStringHashNode key, \n"
" int create_missing=0) -> CvFileNode\n"
""},
{ (char *)"cvGetFileNodeByName", _wrap_cvGetFileNodeByName, METH_VARARGS, (char *)"cvGetFileNodeByName(CvFileStorage fs, CvFileNode map, char name) -> CvFileNode"},
{ (char *)"cvReadInt", _wrap_cvReadInt, METH_VARARGS, (char *)"cvReadInt(CvFileNode node, int default_value=0) -> int"},
{ (char *)"cvReadIntByName", _wrap_cvReadIntByName, METH_VARARGS, (char *)"cvReadIntByName(CvFileStorage fs, CvFileNode map, char name, int default_value=0) -> int"},
{ (char *)"cvReadReal", _wrap_cvReadReal, METH_VARARGS, (char *)"cvReadReal(CvFileNode node, double default_value=0.) -> double"},
{ (char *)"cvReadRealByName", _wrap_cvReadRealByName, METH_VARARGS, (char *)"cvReadRealByName(CvFileStorage fs, CvFileNode map, char name, double default_value=0.) -> double"},
{ (char *)"cvReadString", _wrap_cvReadString, METH_VARARGS, (char *)"cvReadString(CvFileNode node, char default_value=None) -> char"},
{ (char *)"cvReadStringByName", _wrap_cvReadStringByName, METH_VARARGS, (char *)"cvReadStringByName(CvFileStorage fs, CvFileNode map, char name, char default_value=None) -> char"},
{ (char *)"cvRead", _wrap_cvRead, METH_VARARGS, (char *)"cvRead(CvFileStorage fs, CvFileNode node, CvAttrList attributes=None) -> void"},
{ (char *)"cvReadByName", _wrap_cvReadByName, METH_VARARGS, (char *)"cvReadByName(CvFileStorage fs, CvFileNode map, char name, CvAttrList attributes=None) -> void"},
{ (char *)"cvStartReadRawData", _wrap_cvStartReadRawData, METH_VARARGS, (char *)"cvStartReadRawData(CvFileStorage fs, CvFileNode src, CvSeqReader reader)"},
{ (char *)"cvReadRawDataSlice", _wrap_cvReadRawDataSlice, METH_VARARGS, (char *)"\n"
"cvReadRawDataSlice(CvFileStorage fs, CvSeqReader reader, int count, void dst, \n"
" char dt)\n"
""},
{ (char *)"cvReadRawData", _wrap_cvReadRawData, METH_VARARGS, (char *)"cvReadRawData(CvFileStorage fs, CvFileNode src, void dst, char dt)"},
{ (char *)"cvWriteFileNode", _wrap_cvWriteFileNode, METH_VARARGS, (char *)"\n"
"cvWriteFileNode(CvFileStorage fs, char new_node_name, CvFileNode node, \n"
" int embed)\n"
""},
{ (char *)"cvGetFileNodeName", _wrap_cvGetFileNodeName, METH_VARARGS, (char *)"cvGetFileNodeName(CvFileNode node) -> char"},
{ (char *)"cvRegisterType", _wrap_cvRegisterType, METH_VARARGS, (char *)"cvRegisterType(CvTypeInfo info)"},
{ (char *)"cvUnregisterType", _wrap_cvUnregisterType, METH_VARARGS, (char *)"cvUnregisterType(char type_name)"},
{ (char *)"cvFirstType", _wrap_cvFirstType, METH_VARARGS, (char *)"cvFirstType() -> CvTypeInfo"},
{ (char *)"cvFindType", _wrap_cvFindType, METH_VARARGS, (char *)"cvFindType(char type_name) -> CvTypeInfo"},
{ (char *)"cvTypeOf", _wrap_cvTypeOf, METH_VARARGS, (char *)"cvTypeOf(void struct_ptr) -> CvTypeInfo"},
{ (char *)"cvClone", _wrap_cvClone, METH_VARARGS, (char *)"cvClone(void struct_ptr) -> void"},
{ (char *)"cvSave", _wrap_cvSave, METH_VARARGS, (char *)"\n"
"cvSave(char filename, void struct_ptr, char name=None, char comment=None, \n"
" CvAttrList attributes=cvAttrList())\n"
""},
{ (char *)"cvLoad", _wrap_cvLoad, METH_VARARGS, (char *)"\n"
"cvLoad(char filename, CvMemStorage memstorage=None, char name=None, \n"
" char real_name=None) -> void\n"
""},
{ (char *)"cvGetTickCount", _wrap_cvGetTickCount, METH_VARARGS, (char *)"cvGetTickCount() -> int64"},
{ (char *)"cvGetTickFrequency", _wrap_cvGetTickFrequency, METH_VARARGS, (char *)"cvGetTickFrequency() -> double"},
{ (char *)"cvGetNumThreads", _wrap_cvGetNumThreads, METH_VARARGS, (char *)"cvGetNumThreads() -> int"},
{ (char *)"cvSetNumThreads", _wrap_cvSetNumThreads, METH_VARARGS, (char *)"cvSetNumThreads(int threads=0)"},
{ (char *)"cvGetThreadNum", _wrap_cvGetThreadNum, METH_VARARGS, (char *)"cvGetThreadNum() -> int"},
{ (char *)"cvSetImageIOFunctions", _wrap_cvSetImageIOFunctions, METH_VARARGS, (char *)"\n"
"cvSetImageIOFunctions(CvLoadImageFunc _load_image, CvLoadImageMFunc _load_image_m, \n"
" CvSaveImageFunc _save_image, CvShowImageFunc _show_image) -> int\n"
""},
{ (char *)"new_CvImage", _wrap_new_CvImage, METH_VARARGS, (char *)"\n"
"CvImage()\n"
"CvImage(CvSize size, int depth, int channels)\n"
"CvImage( img)\n"
"CvImage(CvImage img)\n"
"CvImage(char filename, char imgname=0, int color=-1)\n"
"CvImage(char filename, char imgname=0)\n"
"CvImage(char filename)\n"
"CvImage(CvFileStorage fs, char mapname, char imgname)\n"
"new_CvImage(CvFileStorage fs, char seqname, int idx) -> CvImage\n"
""},
{ (char *)"delete_CvImage", _wrap_delete_CvImage, METH_VARARGS, (char *)"delete_CvImage(CvImage self)"},
{ (char *)"CvImage_clone", _wrap_CvImage_clone, METH_VARARGS, (char *)"CvImage_clone(CvImage self) -> CvImage"},
{ (char *)"CvImage_create", _wrap_CvImage_create, METH_VARARGS, (char *)"CvImage_create(CvImage self, CvSize size, int depth, int channels)"},
{ (char *)"CvImage_release", _wrap_CvImage_release, METH_VARARGS, (char *)"CvImage_release(CvImage self)"},
{ (char *)"CvImage_clear", _wrap_CvImage_clear, METH_VARARGS, (char *)"CvImage_clear(CvImage self)"},
{ (char *)"CvImage_attach", _wrap_CvImage_attach, METH_VARARGS, (char *)"\n"
"attach( img, bool use_refcount=True)\n"
"CvImage_attach(CvImage self, img)\n"
""},
{ (char *)"CvImage_detach", _wrap_CvImage_detach, METH_VARARGS, (char *)"CvImage_detach(CvImage self)"},
{ (char *)"CvImage_load", _wrap_CvImage_load, METH_VARARGS, (char *)"\n"
"load(char filename, char imgname=0, int color=-1) -> bool\n"
"load(char filename, char imgname=0) -> bool\n"
"CvImage_load(CvImage self, char filename) -> bool\n"
""},
{ (char *)"CvImage_read", _wrap_CvImage_read, METH_VARARGS, (char *)"\n"
"read(CvFileStorage fs, char mapname, char imgname) -> bool\n"
"CvImage_read(CvImage self, CvFileStorage fs, char seqname, int idx) -> bool\n"
""},
{ (char *)"CvImage_save", _wrap_CvImage_save, METH_VARARGS, (char *)"CvImage_save(CvImage self, char filename, char imgname)"},
{ (char *)"CvImage_write", _wrap_CvImage_write, METH_VARARGS, (char *)"CvImage_write(CvImage self, CvFileStorage fs, char imgname)"},
{ (char *)"CvImage_show", _wrap_CvImage_show, METH_VARARGS, (char *)"CvImage_show(CvImage self, char window_name)"},
{ (char *)"CvImage_is_valid", _wrap_CvImage_is_valid, METH_VARARGS, (char *)"CvImage_is_valid(CvImage self) -> bool"},
{ (char *)"CvImage_width", _wrap_CvImage_width, METH_VARARGS, (char *)"CvImage_width(CvImage self) -> int"},
{ (char *)"CvImage_height", _wrap_CvImage_height, METH_VARARGS, (char *)"CvImage_height(CvImage self) -> int"},
{ (char *)"CvImage_size", _wrap_CvImage_size, METH_VARARGS, (char *)"CvImage_size(CvImage self) -> CvSize"},
{ (char *)"CvImage_roi_size", _wrap_CvImage_roi_size, METH_VARARGS, (char *)"CvImage_roi_size(CvImage self) -> CvSize"},
{ (char *)"CvImage_roi", _wrap_CvImage_roi, METH_VARARGS, (char *)"CvImage_roi(CvImage self) -> CvRect"},
{ (char *)"CvImage_coi", _wrap_CvImage_coi, METH_VARARGS, (char *)"CvImage_coi(CvImage self) -> int"},
{ (char *)"CvImage_set_roi", _wrap_CvImage_set_roi, METH_VARARGS, (char *)"CvImage_set_roi(CvImage self, CvRect roi)"},
{ (char *)"CvImage_reset_roi", _wrap_CvImage_reset_roi, METH_VARARGS, (char *)"CvImage_reset_roi(CvImage self)"},
{ (char *)"CvImage_set_coi", _wrap_CvImage_set_coi, METH_VARARGS, (char *)"CvImage_set_coi(CvImage self, int coi)"},
{ (char *)"CvImage_depth", _wrap_CvImage_depth, METH_VARARGS, (char *)"CvImage_depth(CvImage self) -> int"},
{ (char *)"CvImage_channels", _wrap_CvImage_channels, METH_VARARGS, (char *)"CvImage_channels(CvImage self) -> int"},
{ (char *)"CvImage_pix_size", _wrap_CvImage_pix_size, METH_VARARGS, (char *)"CvImage_pix_size(CvImage self) -> int"},
{ (char *)"CvImage_data", _wrap_CvImage_data, METH_VARARGS, (char *)"\n"
"data() -> uchar\n"
"CvImage_data(CvImage self) -> uchar\n"
""},
{ (char *)"CvImage_step", _wrap_CvImage_step, METH_VARARGS, (char *)"CvImage_step(CvImage self) -> int"},
{ (char *)"CvImage_origin", _wrap_CvImage_origin, METH_VARARGS, (char *)"CvImage_origin(CvImage self) -> int"},
{ (char *)"CvImage_roi_row", _wrap_CvImage_roi_row, METH_VARARGS, (char *)"\n"
"roi_row(int y) -> uchar\n"
"CvImage_roi_row(CvImage self, int y) -> uchar\n"
""},
{ (char *)"CvImage_asIplImage", _wrap_CvImage_asIplImage, METH_VARARGS, (char *)"CvImage_asIplImage(CvImage self)"},
{ (char *)"CvImage_swigregister", CvImage_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvMatrix", _wrap_new_CvMatrix, METH_VARARGS, (char *)"\n"
"CvMatrix()\n"
"CvMatrix(int rows, int cols, int type)\n"
"CvMatrix(int rows, int cols, int type, CvMat hdr, void data=0, \n"
" int step=0x7fffffff)\n"
"CvMatrix(int rows, int cols, int type, CvMat hdr, void data=0)\n"
"CvMatrix(int rows, int cols, int type, CvMat hdr)\n"
"CvMatrix(int rows, int cols, int type, CvMemStorage storage, \n"
" bool alloc_data=True)\n"
"CvMatrix(int rows, int cols, int type, CvMemStorage storage)\n"
"CvMatrix(int rows, int cols, int type, void data, int step=0x7fffffff)\n"
"CvMatrix(int rows, int cols, int type, void data)\n"
"CvMatrix(CvMat m)\n"
"CvMatrix(CvMatrix m)\n"
"CvMatrix(char filename, char matname=0, int color=-1)\n"
"CvMatrix(char filename, char matname=0)\n"
"CvMatrix(char filename)\n"
"CvMatrix(CvFileStorage fs, char mapname, char matname)\n"
"new_CvMatrix(CvFileStorage fs, char seqname, int idx) -> CvMatrix\n"
""},
{ (char *)"delete_CvMatrix", _wrap_delete_CvMatrix, METH_VARARGS, (char *)"delete_CvMatrix(CvMatrix self)"},
{ (char *)"CvMatrix_clone", _wrap_CvMatrix_clone, METH_VARARGS, (char *)"CvMatrix_clone(CvMatrix self) -> CvMatrix"},
{ (char *)"CvMatrix_set", _wrap_CvMatrix_set, METH_VARARGS, (char *)"CvMatrix_set(CvMatrix self, CvMat m, bool add_ref)"},
{ (char *)"CvMatrix_create", _wrap_CvMatrix_create, METH_VARARGS, (char *)"CvMatrix_create(CvMatrix self, int rows, int cols, int type)"},
{ (char *)"CvMatrix_addref", _wrap_CvMatrix_addref, METH_VARARGS, (char *)"CvMatrix_addref(CvMatrix self)"},
{ (char *)"CvMatrix_release", _wrap_CvMatrix_release, METH_VARARGS, (char *)"CvMatrix_release(CvMatrix self)"},
{ (char *)"CvMatrix_clear", _wrap_CvMatrix_clear, METH_VARARGS, (char *)"CvMatrix_clear(CvMatrix self)"},
{ (char *)"CvMatrix_load", _wrap_CvMatrix_load, METH_VARARGS, (char *)"\n"
"load(char filename, char matname=0, int color=-1) -> bool\n"
"load(char filename, char matname=0) -> bool\n"
"CvMatrix_load(CvMatrix self, char filename) -> bool\n"
""},
{ (char *)"CvMatrix_read", _wrap_CvMatrix_read, METH_VARARGS, (char *)"\n"
"read(CvFileStorage fs, char mapname, char matname) -> bool\n"
"CvMatrix_read(CvMatrix self, CvFileStorage fs, char seqname, int idx) -> bool\n"
""},
{ (char *)"CvMatrix_save", _wrap_CvMatrix_save, METH_VARARGS, (char *)"CvMatrix_save(CvMatrix self, char filename, char matname)"},
{ (char *)"CvMatrix_write", _wrap_CvMatrix_write, METH_VARARGS, (char *)"CvMatrix_write(CvMatrix self, CvFileStorage fs, char matname)"},
{ (char *)"CvMatrix_show", _wrap_CvMatrix_show, METH_VARARGS, (char *)"CvMatrix_show(CvMatrix self, char window_name)"},
{ (char *)"CvMatrix_is_valid", _wrap_CvMatrix_is_valid, METH_VARARGS, (char *)"CvMatrix_is_valid(CvMatrix self) -> bool"},
{ (char *)"CvMatrix_rows", _wrap_CvMatrix_rows, METH_VARARGS, (char *)"CvMatrix_rows(CvMatrix self) -> int"},
{ (char *)"CvMatrix_cols", _wrap_CvMatrix_cols, METH_VARARGS, (char *)"CvMatrix_cols(CvMatrix self) -> int"},
{ (char *)"CvMatrix_size", _wrap_CvMatrix_size, METH_VARARGS, (char *)"CvMatrix_size(CvMatrix self) -> CvSize"},
{ (char *)"CvMatrix_type", _wrap_CvMatrix_type, METH_VARARGS, (char *)"CvMatrix_type(CvMatrix self) -> int"},
{ (char *)"CvMatrix_depth", _wrap_CvMatrix_depth, METH_VARARGS, (char *)"CvMatrix_depth(CvMatrix self) -> int"},
{ (char *)"CvMatrix_channels", _wrap_CvMatrix_channels, METH_VARARGS, (char *)"CvMatrix_channels(CvMatrix self) -> int"},
{ (char *)"CvMatrix_pix_size", _wrap_CvMatrix_pix_size, METH_VARARGS, (char *)"CvMatrix_pix_size(CvMatrix self) -> int"},
{ (char *)"CvMatrix_data", _wrap_CvMatrix_data, METH_VARARGS, (char *)"\n"
"data() -> uchar\n"
"CvMatrix_data(CvMatrix self) -> uchar\n"
""},
{ (char *)"CvMatrix_step", _wrap_CvMatrix_step, METH_VARARGS, (char *)"CvMatrix_step(CvMatrix self) -> int"},
{ (char *)"CvMatrix_set_data", _wrap_CvMatrix_set_data, METH_VARARGS, (char *)"\n"
"set_data(void data, int step=0x7fffffff)\n"
"CvMatrix_set_data(CvMatrix self, void data)\n"
""},
{ (char *)"CvMatrix_row", _wrap_CvMatrix_row, METH_VARARGS, (char *)"\n"
"row(int i) -> uchar\n"
"CvMatrix_row(CvMatrix self, int i) -> uchar\n"
""},
{ (char *)"CvMatrix_asCvMat", _wrap_CvMatrix_asCvMat, METH_VARARGS, (char *)"CvMatrix_asCvMat(CvMatrix self) -> CvMat"},
{ (char *)"CvMatrix_swigregister", CvMatrix_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvModule", _wrap_new_CvModule, METH_VARARGS, (char *)"new_CvModule(CvModuleInfo _info) -> CvModule"},
{ (char *)"delete_CvModule", _wrap_delete_CvModule, METH_VARARGS, (char *)"delete_CvModule(CvModule self)"},
{ (char *)"CvModule_info_set", _wrap_CvModule_info_set, METH_VARARGS, (char *)"CvModule_info_set(CvModule self, CvModuleInfo info)"},
{ (char *)"CvModule_info_get", _wrap_CvModule_info_get, METH_VARARGS, (char *)"CvModule_info_get(CvModule self) -> CvModuleInfo"},
{ (char *)"CvModule_first_get", _wrap_CvModule_first_get, METH_VARARGS, NULL},
{ (char *)"CvModule_first_set", _wrap_CvModule_first_set, METH_VARARGS, NULL},
{ (char *)"CvModule_last_get", _wrap_CvModule_last_get, METH_VARARGS, NULL},
{ (char *)"CvModule_last_set", _wrap_CvModule_last_set, METH_VARARGS, NULL},
{ (char *)"CvModule_swigregister", CvModule_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvType", _wrap_new_CvType, METH_VARARGS, (char *)"\n"
"CvType(char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release=0, \n"
" CvReadFunc read=0, CvWriteFunc write=0, \n"
" CvCloneFunc clone=0)\n"
"CvType(char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release=0, \n"
" CvReadFunc read=0, CvWriteFunc write=0)\n"
"CvType(char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release=0, \n"
" CvReadFunc read=0)\n"
"CvType(char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release=0)\n"
"new_CvType(char type_name, CvIsInstanceFunc is_instance) -> CvType\n"
""},
{ (char *)"delete_CvType", _wrap_delete_CvType, METH_VARARGS, (char *)"delete_CvType(CvType self)"},
{ (char *)"CvType_info_set", _wrap_CvType_info_set, METH_VARARGS, (char *)"CvType_info_set(CvType self, CvTypeInfo info)"},
{ (char *)"CvType_info_get", _wrap_CvType_info_get, METH_VARARGS, (char *)"CvType_info_get(CvType self) -> CvTypeInfo"},
{ (char *)"CvType_first_get", _wrap_CvType_first_get, METH_VARARGS, NULL},
{ (char *)"CvType_first_set", _wrap_CvType_first_set, METH_VARARGS, NULL},
{ (char *)"CvType_last_get", _wrap_CvType_last_get, METH_VARARGS, NULL},
{ (char *)"CvType_last_set", _wrap_CvType_last_set, METH_VARARGS, NULL},
{ (char *)"CvType_swigregister", CvType_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMoments_m00_set", _wrap_CvMoments_m00_set, METH_VARARGS, (char *)"CvMoments_m00_set(CvMoments self, double m00)"},
{ (char *)"CvMoments_m00_get", _wrap_CvMoments_m00_get, METH_VARARGS, (char *)"CvMoments_m00_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m10_set", _wrap_CvMoments_m10_set, METH_VARARGS, (char *)"CvMoments_m10_set(CvMoments self, double m10)"},
{ (char *)"CvMoments_m10_get", _wrap_CvMoments_m10_get, METH_VARARGS, (char *)"CvMoments_m10_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m01_set", _wrap_CvMoments_m01_set, METH_VARARGS, (char *)"CvMoments_m01_set(CvMoments self, double m01)"},
{ (char *)"CvMoments_m01_get", _wrap_CvMoments_m01_get, METH_VARARGS, (char *)"CvMoments_m01_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m20_set", _wrap_CvMoments_m20_set, METH_VARARGS, (char *)"CvMoments_m20_set(CvMoments self, double m20)"},
{ (char *)"CvMoments_m20_get", _wrap_CvMoments_m20_get, METH_VARARGS, (char *)"CvMoments_m20_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m11_set", _wrap_CvMoments_m11_set, METH_VARARGS, (char *)"CvMoments_m11_set(CvMoments self, double m11)"},
{ (char *)"CvMoments_m11_get", _wrap_CvMoments_m11_get, METH_VARARGS, (char *)"CvMoments_m11_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m02_set", _wrap_CvMoments_m02_set, METH_VARARGS, (char *)"CvMoments_m02_set(CvMoments self, double m02)"},
{ (char *)"CvMoments_m02_get", _wrap_CvMoments_m02_get, METH_VARARGS, (char *)"CvMoments_m02_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m30_set", _wrap_CvMoments_m30_set, METH_VARARGS, (char *)"CvMoments_m30_set(CvMoments self, double m30)"},
{ (char *)"CvMoments_m30_get", _wrap_CvMoments_m30_get, METH_VARARGS, (char *)"CvMoments_m30_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m21_set", _wrap_CvMoments_m21_set, METH_VARARGS, (char *)"CvMoments_m21_set(CvMoments self, double m21)"},
{ (char *)"CvMoments_m21_get", _wrap_CvMoments_m21_get, METH_VARARGS, (char *)"CvMoments_m21_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m12_set", _wrap_CvMoments_m12_set, METH_VARARGS, (char *)"CvMoments_m12_set(CvMoments self, double m12)"},
{ (char *)"CvMoments_m12_get", _wrap_CvMoments_m12_get, METH_VARARGS, (char *)"CvMoments_m12_get(CvMoments self) -> double"},
{ (char *)"CvMoments_m03_set", _wrap_CvMoments_m03_set, METH_VARARGS, (char *)"CvMoments_m03_set(CvMoments self, double m03)"},
{ (char *)"CvMoments_m03_get", _wrap_CvMoments_m03_get, METH_VARARGS, (char *)"CvMoments_m03_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu20_set", _wrap_CvMoments_mu20_set, METH_VARARGS, (char *)"CvMoments_mu20_set(CvMoments self, double mu20)"},
{ (char *)"CvMoments_mu20_get", _wrap_CvMoments_mu20_get, METH_VARARGS, (char *)"CvMoments_mu20_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu11_set", _wrap_CvMoments_mu11_set, METH_VARARGS, (char *)"CvMoments_mu11_set(CvMoments self, double mu11)"},
{ (char *)"CvMoments_mu11_get", _wrap_CvMoments_mu11_get, METH_VARARGS, (char *)"CvMoments_mu11_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu02_set", _wrap_CvMoments_mu02_set, METH_VARARGS, (char *)"CvMoments_mu02_set(CvMoments self, double mu02)"},
{ (char *)"CvMoments_mu02_get", _wrap_CvMoments_mu02_get, METH_VARARGS, (char *)"CvMoments_mu02_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu30_set", _wrap_CvMoments_mu30_set, METH_VARARGS, (char *)"CvMoments_mu30_set(CvMoments self, double mu30)"},
{ (char *)"CvMoments_mu30_get", _wrap_CvMoments_mu30_get, METH_VARARGS, (char *)"CvMoments_mu30_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu21_set", _wrap_CvMoments_mu21_set, METH_VARARGS, (char *)"CvMoments_mu21_set(CvMoments self, double mu21)"},
{ (char *)"CvMoments_mu21_get", _wrap_CvMoments_mu21_get, METH_VARARGS, (char *)"CvMoments_mu21_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu12_set", _wrap_CvMoments_mu12_set, METH_VARARGS, (char *)"CvMoments_mu12_set(CvMoments self, double mu12)"},
{ (char *)"CvMoments_mu12_get", _wrap_CvMoments_mu12_get, METH_VARARGS, (char *)"CvMoments_mu12_get(CvMoments self) -> double"},
{ (char *)"CvMoments_mu03_set", _wrap_CvMoments_mu03_set, METH_VARARGS, (char *)"CvMoments_mu03_set(CvMoments self, double mu03)"},
{ (char *)"CvMoments_mu03_get", _wrap_CvMoments_mu03_get, METH_VARARGS, (char *)"CvMoments_mu03_get(CvMoments self) -> double"},
{ (char *)"CvMoments_inv_sqrt_m00_set", _wrap_CvMoments_inv_sqrt_m00_set, METH_VARARGS, (char *)"CvMoments_inv_sqrt_m00_set(CvMoments self, double inv_sqrt_m00)"},
{ (char *)"CvMoments_inv_sqrt_m00_get", _wrap_CvMoments_inv_sqrt_m00_get, METH_VARARGS, (char *)"CvMoments_inv_sqrt_m00_get(CvMoments self) -> double"},
{ (char *)"new_CvMoments", _wrap_new_CvMoments, METH_VARARGS, (char *)"new_CvMoments() -> CvMoments"},
{ (char *)"delete_CvMoments", _wrap_delete_CvMoments, METH_VARARGS, (char *)"delete_CvMoments(CvMoments self)"},
{ (char *)"CvMoments_swigregister", CvMoments_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHuMoments_hu1_set", _wrap_CvHuMoments_hu1_set, METH_VARARGS, (char *)"CvHuMoments_hu1_set(CvHuMoments self, double hu1)"},
{ (char *)"CvHuMoments_hu1_get", _wrap_CvHuMoments_hu1_get, METH_VARARGS, (char *)"CvHuMoments_hu1_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu2_set", _wrap_CvHuMoments_hu2_set, METH_VARARGS, (char *)"CvHuMoments_hu2_set(CvHuMoments self, double hu2)"},
{ (char *)"CvHuMoments_hu2_get", _wrap_CvHuMoments_hu2_get, METH_VARARGS, (char *)"CvHuMoments_hu2_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu3_set", _wrap_CvHuMoments_hu3_set, METH_VARARGS, (char *)"CvHuMoments_hu3_set(CvHuMoments self, double hu3)"},
{ (char *)"CvHuMoments_hu3_get", _wrap_CvHuMoments_hu3_get, METH_VARARGS, (char *)"CvHuMoments_hu3_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu4_set", _wrap_CvHuMoments_hu4_set, METH_VARARGS, (char *)"CvHuMoments_hu4_set(CvHuMoments self, double hu4)"},
{ (char *)"CvHuMoments_hu4_get", _wrap_CvHuMoments_hu4_get, METH_VARARGS, (char *)"CvHuMoments_hu4_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu5_set", _wrap_CvHuMoments_hu5_set, METH_VARARGS, (char *)"CvHuMoments_hu5_set(CvHuMoments self, double hu5)"},
{ (char *)"CvHuMoments_hu5_get", _wrap_CvHuMoments_hu5_get, METH_VARARGS, (char *)"CvHuMoments_hu5_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu6_set", _wrap_CvHuMoments_hu6_set, METH_VARARGS, (char *)"CvHuMoments_hu6_set(CvHuMoments self, double hu6)"},
{ (char *)"CvHuMoments_hu6_get", _wrap_CvHuMoments_hu6_get, METH_VARARGS, (char *)"CvHuMoments_hu6_get(CvHuMoments self) -> double"},
{ (char *)"CvHuMoments_hu7_set", _wrap_CvHuMoments_hu7_set, METH_VARARGS, (char *)"CvHuMoments_hu7_set(CvHuMoments self, double hu7)"},
{ (char *)"CvHuMoments_hu7_get", _wrap_CvHuMoments_hu7_get, METH_VARARGS, (char *)"CvHuMoments_hu7_get(CvHuMoments self) -> double"},
{ (char *)"new_CvHuMoments", _wrap_new_CvHuMoments, METH_VARARGS, (char *)"new_CvHuMoments() -> CvHuMoments"},
{ (char *)"delete_CvHuMoments", _wrap_delete_CvHuMoments, METH_VARARGS, (char *)"delete_CvHuMoments(CvHuMoments self)"},
{ (char *)"CvHuMoments_swigregister", CvHuMoments_swigregister, METH_VARARGS, NULL},
{ (char *)"CvConnectedComp_area_set", _wrap_CvConnectedComp_area_set, METH_VARARGS, (char *)"CvConnectedComp_area_set(CvConnectedComp self, double area)"},
{ (char *)"CvConnectedComp_area_get", _wrap_CvConnectedComp_area_get, METH_VARARGS, (char *)"CvConnectedComp_area_get(CvConnectedComp self) -> double"},
{ (char *)"CvConnectedComp_value_set", _wrap_CvConnectedComp_value_set, METH_VARARGS, (char *)"CvConnectedComp_value_set(CvConnectedComp self, CvScalar value)"},
{ (char *)"CvConnectedComp_value_get", _wrap_CvConnectedComp_value_get, METH_VARARGS, (char *)"CvConnectedComp_value_get(CvConnectedComp self) -> CvScalar"},
{ (char *)"CvConnectedComp_rect_set", _wrap_CvConnectedComp_rect_set, METH_VARARGS, (char *)"CvConnectedComp_rect_set(CvConnectedComp self, CvRect rect)"},
{ (char *)"CvConnectedComp_rect_get", _wrap_CvConnectedComp_rect_get, METH_VARARGS, (char *)"CvConnectedComp_rect_get(CvConnectedComp self) -> CvRect"},
{ (char *)"CvConnectedComp_contour_set", _wrap_CvConnectedComp_contour_set, METH_VARARGS, (char *)"CvConnectedComp_contour_set(CvConnectedComp self, CvSeq contour)"},
{ (char *)"CvConnectedComp_contour_get", _wrap_CvConnectedComp_contour_get, METH_VARARGS, (char *)"CvConnectedComp_contour_get(CvConnectedComp self) -> CvSeq"},
{ (char *)"new_CvConnectedComp", _wrap_new_CvConnectedComp, METH_VARARGS, (char *)"new_CvConnectedComp() -> CvConnectedComp"},
{ (char *)"delete_CvConnectedComp", _wrap_delete_CvConnectedComp, METH_VARARGS, (char *)"delete_CvConnectedComp(CvConnectedComp self)"},
{ (char *)"CvConnectedComp_swigregister", CvConnectedComp_swigregister, METH_VARARGS, NULL},
{ (char *)"CvChainPtReader_header_size_set", _wrap_CvChainPtReader_header_size_set, METH_VARARGS, (char *)"CvChainPtReader_header_size_set(CvChainPtReader self, int header_size)"},
{ (char *)"CvChainPtReader_header_size_get", _wrap_CvChainPtReader_header_size_get, METH_VARARGS, (char *)"CvChainPtReader_header_size_get(CvChainPtReader self) -> int"},
{ (char *)"CvChainPtReader_seq_set", _wrap_CvChainPtReader_seq_set, METH_VARARGS, (char *)"CvChainPtReader_seq_set(CvChainPtReader self, CvSeq seq)"},
{ (char *)"CvChainPtReader_seq_get", _wrap_CvChainPtReader_seq_get, METH_VARARGS, (char *)"CvChainPtReader_seq_get(CvChainPtReader self) -> CvSeq"},
{ (char *)"CvChainPtReader_block_set", _wrap_CvChainPtReader_block_set, METH_VARARGS, (char *)"CvChainPtReader_block_set(CvChainPtReader self, CvSeqBlock block)"},
{ (char *)"CvChainPtReader_block_get", _wrap_CvChainPtReader_block_get, METH_VARARGS, (char *)"CvChainPtReader_block_get(CvChainPtReader self) -> CvSeqBlock"},
{ (char *)"CvChainPtReader_ptr_set", _wrap_CvChainPtReader_ptr_set, METH_VARARGS, (char *)"CvChainPtReader_ptr_set(CvChainPtReader self, schar ptr)"},
{ (char *)"CvChainPtReader_ptr_get", _wrap_CvChainPtReader_ptr_get, METH_VARARGS, (char *)"CvChainPtReader_ptr_get(CvChainPtReader self) -> schar"},
{ (char *)"CvChainPtReader_block_min_set", _wrap_CvChainPtReader_block_min_set, METH_VARARGS, (char *)"CvChainPtReader_block_min_set(CvChainPtReader self, schar block_min)"},
{ (char *)"CvChainPtReader_block_min_get", _wrap_CvChainPtReader_block_min_get, METH_VARARGS, (char *)"CvChainPtReader_block_min_get(CvChainPtReader self) -> schar"},
{ (char *)"CvChainPtReader_block_max_set", _wrap_CvChainPtReader_block_max_set, METH_VARARGS, (char *)"CvChainPtReader_block_max_set(CvChainPtReader self, schar block_max)"},
{ (char *)"CvChainPtReader_block_max_get", _wrap_CvChainPtReader_block_max_get, METH_VARARGS, (char *)"CvChainPtReader_block_max_get(CvChainPtReader self) -> schar"},
{ (char *)"CvChainPtReader_delta_index_set", _wrap_CvChainPtReader_delta_index_set, METH_VARARGS, (char *)"CvChainPtReader_delta_index_set(CvChainPtReader self, int delta_index)"},
{ (char *)"CvChainPtReader_delta_index_get", _wrap_CvChainPtReader_delta_index_get, METH_VARARGS, (char *)"CvChainPtReader_delta_index_get(CvChainPtReader self) -> int"},
{ (char *)"CvChainPtReader_prev_elem_set", _wrap_CvChainPtReader_prev_elem_set, METH_VARARGS, (char *)"CvChainPtReader_prev_elem_set(CvChainPtReader self, schar prev_elem)"},
{ (char *)"CvChainPtReader_prev_elem_get", _wrap_CvChainPtReader_prev_elem_get, METH_VARARGS, (char *)"CvChainPtReader_prev_elem_get(CvChainPtReader self) -> schar"},
{ (char *)"CvChainPtReader_code_set", _wrap_CvChainPtReader_code_set, METH_VARARGS, (char *)"CvChainPtReader_code_set(CvChainPtReader self, char code)"},
{ (char *)"CvChainPtReader_code_get", _wrap_CvChainPtReader_code_get, METH_VARARGS, (char *)"CvChainPtReader_code_get(CvChainPtReader self) -> char"},
{ (char *)"CvChainPtReader_pt_set", _wrap_CvChainPtReader_pt_set, METH_VARARGS, (char *)"CvChainPtReader_pt_set(CvChainPtReader self, CvPoint pt)"},
{ (char *)"CvChainPtReader_pt_get", _wrap_CvChainPtReader_pt_get, METH_VARARGS, (char *)"CvChainPtReader_pt_get(CvChainPtReader self) -> CvPoint"},
{ (char *)"CvChainPtReader_deltas_set", _wrap_CvChainPtReader_deltas_set, METH_VARARGS, (char *)"CvChainPtReader_deltas_set(CvChainPtReader self, schar deltas)"},
{ (char *)"CvChainPtReader_deltas_get", _wrap_CvChainPtReader_deltas_get, METH_VARARGS, (char *)"CvChainPtReader_deltas_get(CvChainPtReader self) -> schar"},
{ (char *)"new_CvChainPtReader", _wrap_new_CvChainPtReader, METH_VARARGS, (char *)"new_CvChainPtReader() -> CvChainPtReader"},
{ (char *)"delete_CvChainPtReader", _wrap_delete_CvChainPtReader, METH_VARARGS, (char *)"delete_CvChainPtReader(CvChainPtReader self)"},
{ (char *)"CvChainPtReader_swigregister", CvChainPtReader_swigregister, METH_VARARGS, NULL},
{ (char *)"CvContourTree_flags_set", _wrap_CvContourTree_flags_set, METH_VARARGS, (char *)"CvContourTree_flags_set(CvContourTree self, int flags)"},
{ (char *)"CvContourTree_flags_get", _wrap_CvContourTree_flags_get, METH_VARARGS, (char *)"CvContourTree_flags_get(CvContourTree self) -> int"},
{ (char *)"CvContourTree_header_size_set", _wrap_CvContourTree_header_size_set, METH_VARARGS, (char *)"CvContourTree_header_size_set(CvContourTree self, int header_size)"},
{ (char *)"CvContourTree_header_size_get", _wrap_CvContourTree_header_size_get, METH_VARARGS, (char *)"CvContourTree_header_size_get(CvContourTree self) -> int"},
{ (char *)"CvContourTree_h_prev_set", _wrap_CvContourTree_h_prev_set, METH_VARARGS, (char *)"CvContourTree_h_prev_set(CvContourTree self, CvSeq h_prev)"},
{ (char *)"CvContourTree_h_prev_get", _wrap_CvContourTree_h_prev_get, METH_VARARGS, (char *)"CvContourTree_h_prev_get(CvContourTree self) -> CvSeq"},
{ (char *)"CvContourTree_h_next_set", _wrap_CvContourTree_h_next_set, METH_VARARGS, (char *)"CvContourTree_h_next_set(CvContourTree self, CvSeq h_next)"},
{ (char *)"CvContourTree_h_next_get", _wrap_CvContourTree_h_next_get, METH_VARARGS, (char *)"CvContourTree_h_next_get(CvContourTree self) -> CvSeq"},
{ (char *)"CvContourTree_v_prev_set", _wrap_CvContourTree_v_prev_set, METH_VARARGS, (char *)"CvContourTree_v_prev_set(CvContourTree self, CvSeq v_prev)"},
{ (char *)"CvContourTree_v_prev_get", _wrap_CvContourTree_v_prev_get, METH_VARARGS, (char *)"CvContourTree_v_prev_get(CvContourTree self) -> CvSeq"},
{ (char *)"CvContourTree_v_next_set", _wrap_CvContourTree_v_next_set, METH_VARARGS, (char *)"CvContourTree_v_next_set(CvContourTree self, CvSeq v_next)"},
{ (char *)"CvContourTree_v_next_get", _wrap_CvContourTree_v_next_get, METH_VARARGS, (char *)"CvContourTree_v_next_get(CvContourTree self) -> CvSeq"},
{ (char *)"CvContourTree_total_set", _wrap_CvContourTree_total_set, METH_VARARGS, (char *)"CvContourTree_total_set(CvContourTree self, int total)"},
{ (char *)"CvContourTree_total_get", _wrap_CvContourTree_total_get, METH_VARARGS, (char *)"CvContourTree_total_get(CvContourTree self) -> int"},
{ (char *)"CvContourTree_elem_size_set", _wrap_CvContourTree_elem_size_set, METH_VARARGS, (char *)"CvContourTree_elem_size_set(CvContourTree self, int elem_size)"},
{ (char *)"CvContourTree_elem_size_get", _wrap_CvContourTree_elem_size_get, METH_VARARGS, (char *)"CvContourTree_elem_size_get(CvContourTree self) -> int"},
{ (char *)"CvContourTree_block_max_set", _wrap_CvContourTree_block_max_set, METH_VARARGS, (char *)"CvContourTree_block_max_set(CvContourTree self, schar block_max)"},
{ (char *)"CvContourTree_block_max_get", _wrap_CvContourTree_block_max_get, METH_VARARGS, (char *)"CvContourTree_block_max_get(CvContourTree self) -> schar"},
{ (char *)"CvContourTree_ptr_set", _wrap_CvContourTree_ptr_set, METH_VARARGS, (char *)"CvContourTree_ptr_set(CvContourTree self, schar ptr)"},
{ (char *)"CvContourTree_ptr_get", _wrap_CvContourTree_ptr_get, METH_VARARGS, (char *)"CvContourTree_ptr_get(CvContourTree self) -> schar"},
{ (char *)"CvContourTree_delta_elems_set", _wrap_CvContourTree_delta_elems_set, METH_VARARGS, (char *)"CvContourTree_delta_elems_set(CvContourTree self, int delta_elems)"},
{ (char *)"CvContourTree_delta_elems_get", _wrap_CvContourTree_delta_elems_get, METH_VARARGS, (char *)"CvContourTree_delta_elems_get(CvContourTree self) -> int"},
{ (char *)"CvContourTree_storage_set", _wrap_CvContourTree_storage_set, METH_VARARGS, (char *)"CvContourTree_storage_set(CvContourTree self, CvMemStorage storage)"},
{ (char *)"CvContourTree_storage_get", _wrap_CvContourTree_storage_get, METH_VARARGS, (char *)"CvContourTree_storage_get(CvContourTree self) -> CvMemStorage"},
{ (char *)"CvContourTree_free_blocks_set", _wrap_CvContourTree_free_blocks_set, METH_VARARGS, (char *)"CvContourTree_free_blocks_set(CvContourTree self, CvSeqBlock free_blocks)"},
{ (char *)"CvContourTree_free_blocks_get", _wrap_CvContourTree_free_blocks_get, METH_VARARGS, (char *)"CvContourTree_free_blocks_get(CvContourTree self) -> CvSeqBlock"},
{ (char *)"CvContourTree_first_set", _wrap_CvContourTree_first_set, METH_VARARGS, (char *)"CvContourTree_first_set(CvContourTree self, CvSeqBlock first)"},
{ (char *)"CvContourTree_first_get", _wrap_CvContourTree_first_get, METH_VARARGS, (char *)"CvContourTree_first_get(CvContourTree self) -> CvSeqBlock"},
{ (char *)"CvContourTree_p1_set", _wrap_CvContourTree_p1_set, METH_VARARGS, (char *)"CvContourTree_p1_set(CvContourTree self, CvPoint p1)"},
{ (char *)"CvContourTree_p1_get", _wrap_CvContourTree_p1_get, METH_VARARGS, (char *)"CvContourTree_p1_get(CvContourTree self) -> CvPoint"},
{ (char *)"CvContourTree_p2_set", _wrap_CvContourTree_p2_set, METH_VARARGS, (char *)"CvContourTree_p2_set(CvContourTree self, CvPoint p2)"},
{ (char *)"CvContourTree_p2_get", _wrap_CvContourTree_p2_get, METH_VARARGS, (char *)"CvContourTree_p2_get(CvContourTree self) -> CvPoint"},
{ (char *)"new_CvContourTree", _wrap_new_CvContourTree, METH_VARARGS, (char *)"new_CvContourTree() -> CvContourTree"},
{ (char *)"delete_CvContourTree", _wrap_delete_CvContourTree, METH_VARARGS, (char *)"delete_CvContourTree(CvContourTree self)"},
{ (char *)"CvContourTree_swigregister", CvContourTree_swigregister, METH_VARARGS, NULL},
{ (char *)"CvConvexityDefect_start_set", _wrap_CvConvexityDefect_start_set, METH_VARARGS, (char *)"CvConvexityDefect_start_set(CvConvexityDefect self, CvPoint start)"},
{ (char *)"CvConvexityDefect_start_get", _wrap_CvConvexityDefect_start_get, METH_VARARGS, (char *)"CvConvexityDefect_start_get(CvConvexityDefect self) -> CvPoint"},
{ (char *)"CvConvexityDefect_end_set", _wrap_CvConvexityDefect_end_set, METH_VARARGS, (char *)"CvConvexityDefect_end_set(CvConvexityDefect self, CvPoint end)"},
{ (char *)"CvConvexityDefect_end_get", _wrap_CvConvexityDefect_end_get, METH_VARARGS, (char *)"CvConvexityDefect_end_get(CvConvexityDefect self) -> CvPoint"},
{ (char *)"CvConvexityDefect_depth_point_set", _wrap_CvConvexityDefect_depth_point_set, METH_VARARGS, (char *)"CvConvexityDefect_depth_point_set(CvConvexityDefect self, CvPoint depth_point)"},
{ (char *)"CvConvexityDefect_depth_point_get", _wrap_CvConvexityDefect_depth_point_get, METH_VARARGS, (char *)"CvConvexityDefect_depth_point_get(CvConvexityDefect self) -> CvPoint"},
{ (char *)"CvConvexityDefect_depth_set", _wrap_CvConvexityDefect_depth_set, METH_VARARGS, (char *)"CvConvexityDefect_depth_set(CvConvexityDefect self, float depth)"},
{ (char *)"CvConvexityDefect_depth_get", _wrap_CvConvexityDefect_depth_get, METH_VARARGS, (char *)"CvConvexityDefect_depth_get(CvConvexityDefect self) -> float"},
{ (char *)"new_CvConvexityDefect", _wrap_new_CvConvexityDefect, METH_VARARGS, (char *)"new_CvConvexityDefect() -> CvConvexityDefect"},
{ (char *)"delete_CvConvexityDefect", _wrap_delete_CvConvexityDefect, METH_VARARGS, (char *)"delete_CvConvexityDefect(CvConvexityDefect self)"},
{ (char *)"CvConvexityDefect_swigregister", CvConvexityDefect_swigregister, METH_VARARGS, NULL},
{ (char *)"CvQuadEdge2D_flags_set", _wrap_CvQuadEdge2D_flags_set, METH_VARARGS, (char *)"CvQuadEdge2D_flags_set(CvQuadEdge2D self, int flags)"},
{ (char *)"CvQuadEdge2D_flags_get", _wrap_CvQuadEdge2D_flags_get, METH_VARARGS, (char *)"CvQuadEdge2D_flags_get(CvQuadEdge2D self) -> int"},
{ (char *)"CvQuadEdge2D_pt_set", _wrap_CvQuadEdge2D_pt_set, METH_VARARGS, (char *)"CvQuadEdge2D_pt_set(CvQuadEdge2D self, CvSubdiv2DPoint pt)"},
{ (char *)"CvQuadEdge2D_pt_get", _wrap_CvQuadEdge2D_pt_get, METH_VARARGS, (char *)"CvQuadEdge2D_pt_get(CvQuadEdge2D self) -> CvSubdiv2DPoint"},
{ (char *)"CvQuadEdge2D_next_set", _wrap_CvQuadEdge2D_next_set, METH_VARARGS, (char *)"CvQuadEdge2D_next_set(CvQuadEdge2D self, CvSubdiv2DEdge next)"},
{ (char *)"CvQuadEdge2D_next_get", _wrap_CvQuadEdge2D_next_get, METH_VARARGS, (char *)"CvQuadEdge2D_next_get(CvQuadEdge2D self) -> CvSubdiv2DEdge"},
{ (char *)"new_CvQuadEdge2D", _wrap_new_CvQuadEdge2D, METH_VARARGS, (char *)"new_CvQuadEdge2D() -> CvQuadEdge2D"},
{ (char *)"delete_CvQuadEdge2D", _wrap_delete_CvQuadEdge2D, METH_VARARGS, (char *)"delete_CvQuadEdge2D(CvQuadEdge2D self)"},
{ (char *)"CvQuadEdge2D_swigregister", CvQuadEdge2D_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSubdiv2DPoint_flags_set", _wrap_CvSubdiv2DPoint_flags_set, METH_VARARGS, (char *)"CvSubdiv2DPoint_flags_set(CvSubdiv2DPoint self, int flags)"},
{ (char *)"CvSubdiv2DPoint_flags_get", _wrap_CvSubdiv2DPoint_flags_get, METH_VARARGS, (char *)"CvSubdiv2DPoint_flags_get(CvSubdiv2DPoint self) -> int"},
{ (char *)"CvSubdiv2DPoint_first_set", _wrap_CvSubdiv2DPoint_first_set, METH_VARARGS, (char *)"CvSubdiv2DPoint_first_set(CvSubdiv2DPoint self, CvSubdiv2DEdge first)"},
{ (char *)"CvSubdiv2DPoint_first_get", _wrap_CvSubdiv2DPoint_first_get, METH_VARARGS, (char *)"CvSubdiv2DPoint_first_get(CvSubdiv2DPoint self) -> CvSubdiv2DEdge"},
{ (char *)"CvSubdiv2DPoint_pt_set", _wrap_CvSubdiv2DPoint_pt_set, METH_VARARGS, (char *)"CvSubdiv2DPoint_pt_set(CvSubdiv2DPoint self, CvPoint2D32f pt)"},
{ (char *)"CvSubdiv2DPoint_pt_get", _wrap_CvSubdiv2DPoint_pt_get, METH_VARARGS, (char *)"CvSubdiv2DPoint_pt_get(CvSubdiv2DPoint self) -> CvPoint2D32f"},
{ (char *)"new_CvSubdiv2DPoint", _wrap_new_CvSubdiv2DPoint, METH_VARARGS, (char *)"new_CvSubdiv2DPoint() -> CvSubdiv2DPoint"},
{ (char *)"delete_CvSubdiv2DPoint", _wrap_delete_CvSubdiv2DPoint, METH_VARARGS, (char *)"delete_CvSubdiv2DPoint(CvSubdiv2DPoint self)"},
{ (char *)"CvSubdiv2DPoint_swigregister", CvSubdiv2DPoint_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSubdiv2D_flags_set", _wrap_CvSubdiv2D_flags_set, METH_VARARGS, (char *)"CvSubdiv2D_flags_set(CvSubdiv2D self, int flags)"},
{ (char *)"CvSubdiv2D_flags_get", _wrap_CvSubdiv2D_flags_get, METH_VARARGS, (char *)"CvSubdiv2D_flags_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_header_size_set", _wrap_CvSubdiv2D_header_size_set, METH_VARARGS, (char *)"CvSubdiv2D_header_size_set(CvSubdiv2D self, int header_size)"},
{ (char *)"CvSubdiv2D_header_size_get", _wrap_CvSubdiv2D_header_size_get, METH_VARARGS, (char *)"CvSubdiv2D_header_size_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_h_prev_set", _wrap_CvSubdiv2D_h_prev_set, METH_VARARGS, (char *)"CvSubdiv2D_h_prev_set(CvSubdiv2D self, CvSeq h_prev)"},
{ (char *)"CvSubdiv2D_h_prev_get", _wrap_CvSubdiv2D_h_prev_get, METH_VARARGS, (char *)"CvSubdiv2D_h_prev_get(CvSubdiv2D self) -> CvSeq"},
{ (char *)"CvSubdiv2D_h_next_set", _wrap_CvSubdiv2D_h_next_set, METH_VARARGS, (char *)"CvSubdiv2D_h_next_set(CvSubdiv2D self, CvSeq h_next)"},
{ (char *)"CvSubdiv2D_h_next_get", _wrap_CvSubdiv2D_h_next_get, METH_VARARGS, (char *)"CvSubdiv2D_h_next_get(CvSubdiv2D self) -> CvSeq"},
{ (char *)"CvSubdiv2D_v_prev_set", _wrap_CvSubdiv2D_v_prev_set, METH_VARARGS, (char *)"CvSubdiv2D_v_prev_set(CvSubdiv2D self, CvSeq v_prev)"},
{ (char *)"CvSubdiv2D_v_prev_get", _wrap_CvSubdiv2D_v_prev_get, METH_VARARGS, (char *)"CvSubdiv2D_v_prev_get(CvSubdiv2D self) -> CvSeq"},
{ (char *)"CvSubdiv2D_v_next_set", _wrap_CvSubdiv2D_v_next_set, METH_VARARGS, (char *)"CvSubdiv2D_v_next_set(CvSubdiv2D self, CvSeq v_next)"},
{ (char *)"CvSubdiv2D_v_next_get", _wrap_CvSubdiv2D_v_next_get, METH_VARARGS, (char *)"CvSubdiv2D_v_next_get(CvSubdiv2D self) -> CvSeq"},
{ (char *)"CvSubdiv2D_total_set", _wrap_CvSubdiv2D_total_set, METH_VARARGS, (char *)"CvSubdiv2D_total_set(CvSubdiv2D self, int total)"},
{ (char *)"CvSubdiv2D_total_get", _wrap_CvSubdiv2D_total_get, METH_VARARGS, (char *)"CvSubdiv2D_total_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_elem_size_set", _wrap_CvSubdiv2D_elem_size_set, METH_VARARGS, (char *)"CvSubdiv2D_elem_size_set(CvSubdiv2D self, int elem_size)"},
{ (char *)"CvSubdiv2D_elem_size_get", _wrap_CvSubdiv2D_elem_size_get, METH_VARARGS, (char *)"CvSubdiv2D_elem_size_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_block_max_set", _wrap_CvSubdiv2D_block_max_set, METH_VARARGS, (char *)"CvSubdiv2D_block_max_set(CvSubdiv2D self, schar block_max)"},
{ (char *)"CvSubdiv2D_block_max_get", _wrap_CvSubdiv2D_block_max_get, METH_VARARGS, (char *)"CvSubdiv2D_block_max_get(CvSubdiv2D self) -> schar"},
{ (char *)"CvSubdiv2D_ptr_set", _wrap_CvSubdiv2D_ptr_set, METH_VARARGS, (char *)"CvSubdiv2D_ptr_set(CvSubdiv2D self, schar ptr)"},
{ (char *)"CvSubdiv2D_ptr_get", _wrap_CvSubdiv2D_ptr_get, METH_VARARGS, (char *)"CvSubdiv2D_ptr_get(CvSubdiv2D self) -> schar"},
{ (char *)"CvSubdiv2D_delta_elems_set", _wrap_CvSubdiv2D_delta_elems_set, METH_VARARGS, (char *)"CvSubdiv2D_delta_elems_set(CvSubdiv2D self, int delta_elems)"},
{ (char *)"CvSubdiv2D_delta_elems_get", _wrap_CvSubdiv2D_delta_elems_get, METH_VARARGS, (char *)"CvSubdiv2D_delta_elems_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_storage_set", _wrap_CvSubdiv2D_storage_set, METH_VARARGS, (char *)"CvSubdiv2D_storage_set(CvSubdiv2D self, CvMemStorage storage)"},
{ (char *)"CvSubdiv2D_storage_get", _wrap_CvSubdiv2D_storage_get, METH_VARARGS, (char *)"CvSubdiv2D_storage_get(CvSubdiv2D self) -> CvMemStorage"},
{ (char *)"CvSubdiv2D_free_blocks_set", _wrap_CvSubdiv2D_free_blocks_set, METH_VARARGS, (char *)"CvSubdiv2D_free_blocks_set(CvSubdiv2D self, CvSeqBlock free_blocks)"},
{ (char *)"CvSubdiv2D_free_blocks_get", _wrap_CvSubdiv2D_free_blocks_get, METH_VARARGS, (char *)"CvSubdiv2D_free_blocks_get(CvSubdiv2D self) -> CvSeqBlock"},
{ (char *)"CvSubdiv2D_first_set", _wrap_CvSubdiv2D_first_set, METH_VARARGS, (char *)"CvSubdiv2D_first_set(CvSubdiv2D self, CvSeqBlock first)"},
{ (char *)"CvSubdiv2D_first_get", _wrap_CvSubdiv2D_first_get, METH_VARARGS, (char *)"CvSubdiv2D_first_get(CvSubdiv2D self) -> CvSeqBlock"},
{ (char *)"CvSubdiv2D_free_elems_set", _wrap_CvSubdiv2D_free_elems_set, METH_VARARGS, (char *)"CvSubdiv2D_free_elems_set(CvSubdiv2D self, CvSetElem free_elems)"},
{ (char *)"CvSubdiv2D_free_elems_get", _wrap_CvSubdiv2D_free_elems_get, METH_VARARGS, (char *)"CvSubdiv2D_free_elems_get(CvSubdiv2D self) -> CvSetElem"},
{ (char *)"CvSubdiv2D_active_count_set", _wrap_CvSubdiv2D_active_count_set, METH_VARARGS, (char *)"CvSubdiv2D_active_count_set(CvSubdiv2D self, int active_count)"},
{ (char *)"CvSubdiv2D_active_count_get", _wrap_CvSubdiv2D_active_count_get, METH_VARARGS, (char *)"CvSubdiv2D_active_count_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_quad_edges_set", _wrap_CvSubdiv2D_quad_edges_set, METH_VARARGS, (char *)"CvSubdiv2D_quad_edges_set(CvSubdiv2D self, int quad_edges)"},
{ (char *)"CvSubdiv2D_quad_edges_get", _wrap_CvSubdiv2D_quad_edges_get, METH_VARARGS, (char *)"CvSubdiv2D_quad_edges_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_is_geometry_valid_set", _wrap_CvSubdiv2D_is_geometry_valid_set, METH_VARARGS, (char *)"CvSubdiv2D_is_geometry_valid_set(CvSubdiv2D self, int is_geometry_valid)"},
{ (char *)"CvSubdiv2D_is_geometry_valid_get", _wrap_CvSubdiv2D_is_geometry_valid_get, METH_VARARGS, (char *)"CvSubdiv2D_is_geometry_valid_get(CvSubdiv2D self) -> int"},
{ (char *)"CvSubdiv2D_recent_edge_set", _wrap_CvSubdiv2D_recent_edge_set, METH_VARARGS, (char *)"CvSubdiv2D_recent_edge_set(CvSubdiv2D self, CvSubdiv2DEdge recent_edge)"},
{ (char *)"CvSubdiv2D_recent_edge_get", _wrap_CvSubdiv2D_recent_edge_get, METH_VARARGS, (char *)"CvSubdiv2D_recent_edge_get(CvSubdiv2D self) -> CvSubdiv2DEdge"},
{ (char *)"CvSubdiv2D_topleft_set", _wrap_CvSubdiv2D_topleft_set, METH_VARARGS, (char *)"CvSubdiv2D_topleft_set(CvSubdiv2D self, CvPoint2D32f topleft)"},
{ (char *)"CvSubdiv2D_topleft_get", _wrap_CvSubdiv2D_topleft_get, METH_VARARGS, (char *)"CvSubdiv2D_topleft_get(CvSubdiv2D self) -> CvPoint2D32f"},
{ (char *)"CvSubdiv2D_bottomright_set", _wrap_CvSubdiv2D_bottomright_set, METH_VARARGS, (char *)"CvSubdiv2D_bottomright_set(CvSubdiv2D self, CvPoint2D32f bottomright)"},
{ (char *)"CvSubdiv2D_bottomright_get", _wrap_CvSubdiv2D_bottomright_get, METH_VARARGS, (char *)"CvSubdiv2D_bottomright_get(CvSubdiv2D self) -> CvPoint2D32f"},
{ (char *)"CvSubdiv2D_edges_set", _wrap_CvSubdiv2D_edges_set, METH_VARARGS, (char *)"CvSubdiv2D_edges_set(CvSubdiv2D self, CvSeq_CvQuadEdge2D typed_edges)"},
{ (char *)"CvSubdiv2D_edges_get", _wrap_CvSubdiv2D_edges_get, METH_VARARGS, (char *)"CvSubdiv2D_edges_get(CvSubdiv2D self) -> CvSeq_CvQuadEdge2D"},
{ (char *)"CvSubdiv2D_typed_edges_get", _wrap_CvSubdiv2D_typed_edges_get, METH_VARARGS, (char *)"CvSubdiv2D_typed_edges_get(CvSubdiv2D self) -> CvSeq_CvQuadEdge2D"},
{ (char *)"CvSubdiv2D_typed_edges_set", _wrap_CvSubdiv2D_typed_edges_set, METH_VARARGS, (char *)"CvSubdiv2D_typed_edges_set(CvSubdiv2D self, CvSeq_CvQuadEdge2D ?)"},
{ (char *)"new_CvSubdiv2D", _wrap_new_CvSubdiv2D, METH_VARARGS, (char *)"new_CvSubdiv2D() -> CvSubdiv2D"},
{ (char *)"delete_CvSubdiv2D", _wrap_delete_CvSubdiv2D, METH_VARARGS, (char *)"delete_CvSubdiv2D(CvSubdiv2D self)"},
{ (char *)"CvSubdiv2D_swigregister", CvSubdiv2D_swigregister, METH_VARARGS, NULL},
{ (char *)"CvMatrix3_m_set", _wrap_CvMatrix3_m_set, METH_VARARGS, (char *)"CvMatrix3_m_set(CvMatrix3 self, float m)"},
{ (char *)"CvMatrix3_m_get", _wrap_CvMatrix3_m_get, METH_VARARGS, (char *)"CvMatrix3_m_get(CvMatrix3 self) -> float"},
{ (char *)"new_CvMatrix3", _wrap_new_CvMatrix3, METH_VARARGS, (char *)"new_CvMatrix3() -> CvMatrix3"},
{ (char *)"delete_CvMatrix3", _wrap_delete_CvMatrix3, METH_VARARGS, (char *)"delete_CvMatrix3(CvMatrix3 self)"},
{ (char *)"CvMatrix3_swigregister", CvMatrix3_swigregister, METH_VARARGS, NULL},
{ (char *)"CvConDensation_MP_set", _wrap_CvConDensation_MP_set, METH_VARARGS, (char *)"CvConDensation_MP_set(CvConDensation self, int MP)"},
{ (char *)"CvConDensation_MP_get", _wrap_CvConDensation_MP_get, METH_VARARGS, (char *)"CvConDensation_MP_get(CvConDensation self) -> int"},
{ (char *)"CvConDensation_DP_set", _wrap_CvConDensation_DP_set, METH_VARARGS, (char *)"CvConDensation_DP_set(CvConDensation self, int DP)"},
{ (char *)"CvConDensation_DP_get", _wrap_CvConDensation_DP_get, METH_VARARGS, (char *)"CvConDensation_DP_get(CvConDensation self) -> int"},
{ (char *)"CvConDensation_DynamMatr_set", _wrap_CvConDensation_DynamMatr_set, METH_VARARGS, (char *)"CvConDensation_DynamMatr_set(CvConDensation self, float DynamMatr)"},
{ (char *)"CvConDensation_DynamMatr_get", _wrap_CvConDensation_DynamMatr_get, METH_VARARGS, (char *)"CvConDensation_DynamMatr_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_State_set", _wrap_CvConDensation_State_set, METH_VARARGS, (char *)"CvConDensation_State_set(CvConDensation self, float State)"},
{ (char *)"CvConDensation_State_get", _wrap_CvConDensation_State_get, METH_VARARGS, (char *)"CvConDensation_State_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_SamplesNum_set", _wrap_CvConDensation_SamplesNum_set, METH_VARARGS, (char *)"CvConDensation_SamplesNum_set(CvConDensation self, int SamplesNum)"},
{ (char *)"CvConDensation_SamplesNum_get", _wrap_CvConDensation_SamplesNum_get, METH_VARARGS, (char *)"CvConDensation_SamplesNum_get(CvConDensation self) -> int"},
{ (char *)"CvConDensation_flSamples_set", _wrap_CvConDensation_flSamples_set, METH_VARARGS, (char *)"CvConDensation_flSamples_set(CvConDensation self, float flSamples)"},
{ (char *)"CvConDensation_flSamples_get", _wrap_CvConDensation_flSamples_get, METH_VARARGS, (char *)"CvConDensation_flSamples_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_flNewSamples_set", _wrap_CvConDensation_flNewSamples_set, METH_VARARGS, (char *)"CvConDensation_flNewSamples_set(CvConDensation self, float flNewSamples)"},
{ (char *)"CvConDensation_flNewSamples_get", _wrap_CvConDensation_flNewSamples_get, METH_VARARGS, (char *)"CvConDensation_flNewSamples_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_flConfidence_set", _wrap_CvConDensation_flConfidence_set, METH_VARARGS, (char *)"CvConDensation_flConfidence_set(CvConDensation self, float flConfidence)"},
{ (char *)"CvConDensation_flConfidence_get", _wrap_CvConDensation_flConfidence_get, METH_VARARGS, (char *)"CvConDensation_flConfidence_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_flCumulative_set", _wrap_CvConDensation_flCumulative_set, METH_VARARGS, (char *)"CvConDensation_flCumulative_set(CvConDensation self, float flCumulative)"},
{ (char *)"CvConDensation_flCumulative_get", _wrap_CvConDensation_flCumulative_get, METH_VARARGS, (char *)"CvConDensation_flCumulative_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_Temp_set", _wrap_CvConDensation_Temp_set, METH_VARARGS, (char *)"CvConDensation_Temp_set(CvConDensation self, float Temp)"},
{ (char *)"CvConDensation_Temp_get", _wrap_CvConDensation_Temp_get, METH_VARARGS, (char *)"CvConDensation_Temp_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_RandomSample_set", _wrap_CvConDensation_RandomSample_set, METH_VARARGS, (char *)"CvConDensation_RandomSample_set(CvConDensation self, float RandomSample)"},
{ (char *)"CvConDensation_RandomSample_get", _wrap_CvConDensation_RandomSample_get, METH_VARARGS, (char *)"CvConDensation_RandomSample_get(CvConDensation self) -> float"},
{ (char *)"CvConDensation_RandS_set", _wrap_CvConDensation_RandS_set, METH_VARARGS, (char *)"CvConDensation_RandS_set(CvConDensation self, CvRandState RandS)"},
{ (char *)"CvConDensation_RandS_get", _wrap_CvConDensation_RandS_get, METH_VARARGS, (char *)"CvConDensation_RandS_get(CvConDensation self) -> CvRandState"},
{ (char *)"delete_CvConDensation", _wrap_delete_CvConDensation, METH_VARARGS, (char *)"delete_CvConDensation(CvConDensation self)"},
{ (char *)"CvConDensation_swigregister", CvConDensation_swigregister, METH_VARARGS, NULL},
{ (char *)"CvKalman_MP_set", _wrap_CvKalman_MP_set, METH_VARARGS, (char *)"CvKalman_MP_set(CvKalman self, int MP)"},
{ (char *)"CvKalman_MP_get", _wrap_CvKalman_MP_get, METH_VARARGS, (char *)"CvKalman_MP_get(CvKalman self) -> int"},
{ (char *)"CvKalman_DP_set", _wrap_CvKalman_DP_set, METH_VARARGS, (char *)"CvKalman_DP_set(CvKalman self, int DP)"},
{ (char *)"CvKalman_DP_get", _wrap_CvKalman_DP_get, METH_VARARGS, (char *)"CvKalman_DP_get(CvKalman self) -> int"},
{ (char *)"CvKalman_CP_set", _wrap_CvKalman_CP_set, METH_VARARGS, (char *)"CvKalman_CP_set(CvKalman self, int CP)"},
{ (char *)"CvKalman_CP_get", _wrap_CvKalman_CP_get, METH_VARARGS, (char *)"CvKalman_CP_get(CvKalman self) -> int"},
{ (char *)"CvKalman_PosterState_set", _wrap_CvKalman_PosterState_set, METH_VARARGS, (char *)"CvKalman_PosterState_set(CvKalman self, float PosterState)"},
{ (char *)"CvKalman_PosterState_get", _wrap_CvKalman_PosterState_get, METH_VARARGS, (char *)"CvKalman_PosterState_get(CvKalman self) -> float"},
{ (char *)"CvKalman_PriorState_set", _wrap_CvKalman_PriorState_set, METH_VARARGS, (char *)"CvKalman_PriorState_set(CvKalman self, float PriorState)"},
{ (char *)"CvKalman_PriorState_get", _wrap_CvKalman_PriorState_get, METH_VARARGS, (char *)"CvKalman_PriorState_get(CvKalman self) -> float"},
{ (char *)"CvKalman_DynamMatr_set", _wrap_CvKalman_DynamMatr_set, METH_VARARGS, (char *)"CvKalman_DynamMatr_set(CvKalman self, float DynamMatr)"},
{ (char *)"CvKalman_DynamMatr_get", _wrap_CvKalman_DynamMatr_get, METH_VARARGS, (char *)"CvKalman_DynamMatr_get(CvKalman self) -> float"},
{ (char *)"CvKalman_MeasurementMatr_set", _wrap_CvKalman_MeasurementMatr_set, METH_VARARGS, (char *)"CvKalman_MeasurementMatr_set(CvKalman self, float MeasurementMatr)"},
{ (char *)"CvKalman_MeasurementMatr_get", _wrap_CvKalman_MeasurementMatr_get, METH_VARARGS, (char *)"CvKalman_MeasurementMatr_get(CvKalman self) -> float"},
{ (char *)"CvKalman_MNCovariance_set", _wrap_CvKalman_MNCovariance_set, METH_VARARGS, (char *)"CvKalman_MNCovariance_set(CvKalman self, float MNCovariance)"},
{ (char *)"CvKalman_MNCovariance_get", _wrap_CvKalman_MNCovariance_get, METH_VARARGS, (char *)"CvKalman_MNCovariance_get(CvKalman self) -> float"},
{ (char *)"CvKalman_PNCovariance_set", _wrap_CvKalman_PNCovariance_set, METH_VARARGS, (char *)"CvKalman_PNCovariance_set(CvKalman self, float PNCovariance)"},
{ (char *)"CvKalman_PNCovariance_get", _wrap_CvKalman_PNCovariance_get, METH_VARARGS, (char *)"CvKalman_PNCovariance_get(CvKalman self) -> float"},
{ (char *)"CvKalman_KalmGainMatr_set", _wrap_CvKalman_KalmGainMatr_set, METH_VARARGS, (char *)"CvKalman_KalmGainMatr_set(CvKalman self, float KalmGainMatr)"},
{ (char *)"CvKalman_KalmGainMatr_get", _wrap_CvKalman_KalmGainMatr_get, METH_VARARGS, (char *)"CvKalman_KalmGainMatr_get(CvKalman self) -> float"},
{ (char *)"CvKalman_PriorErrorCovariance_set", _wrap_CvKalman_PriorErrorCovariance_set, METH_VARARGS, (char *)"CvKalman_PriorErrorCovariance_set(CvKalman self, float PriorErrorCovariance)"},
{ (char *)"CvKalman_PriorErrorCovariance_get", _wrap_CvKalman_PriorErrorCovariance_get, METH_VARARGS, (char *)"CvKalman_PriorErrorCovariance_get(CvKalman self) -> float"},
{ (char *)"CvKalman_PosterErrorCovariance_set", _wrap_CvKalman_PosterErrorCovariance_set, METH_VARARGS, (char *)"CvKalman_PosterErrorCovariance_set(CvKalman self, float PosterErrorCovariance)"},
{ (char *)"CvKalman_PosterErrorCovariance_get", _wrap_CvKalman_PosterErrorCovariance_get, METH_VARARGS, (char *)"CvKalman_PosterErrorCovariance_get(CvKalman self) -> float"},
{ (char *)"CvKalman_Temp1_set", _wrap_CvKalman_Temp1_set, METH_VARARGS, (char *)"CvKalman_Temp1_set(CvKalman self, float Temp1)"},
{ (char *)"CvKalman_Temp1_get", _wrap_CvKalman_Temp1_get, METH_VARARGS, (char *)"CvKalman_Temp1_get(CvKalman self) -> float"},
{ (char *)"CvKalman_Temp2_set", _wrap_CvKalman_Temp2_set, METH_VARARGS, (char *)"CvKalman_Temp2_set(CvKalman self, float Temp2)"},
{ (char *)"CvKalman_Temp2_get", _wrap_CvKalman_Temp2_get, METH_VARARGS, (char *)"CvKalman_Temp2_get(CvKalman self) -> float"},
{ (char *)"CvKalman_state_pre_set", _wrap_CvKalman_state_pre_set, METH_VARARGS, (char *)"CvKalman_state_pre_set(CvKalman self, CvMat state_pre)"},
{ (char *)"CvKalman_state_pre_get", _wrap_CvKalman_state_pre_get, METH_VARARGS, (char *)"CvKalman_state_pre_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_state_post_set", _wrap_CvKalman_state_post_set, METH_VARARGS, (char *)"CvKalman_state_post_set(CvKalman self, CvMat state_post)"},
{ (char *)"CvKalman_state_post_get", _wrap_CvKalman_state_post_get, METH_VARARGS, (char *)"CvKalman_state_post_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_transition_matrix_set", _wrap_CvKalman_transition_matrix_set, METH_VARARGS, (char *)"CvKalman_transition_matrix_set(CvKalman self, CvMat transition_matrix)"},
{ (char *)"CvKalman_transition_matrix_get", _wrap_CvKalman_transition_matrix_get, METH_VARARGS, (char *)"CvKalman_transition_matrix_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_control_matrix_set", _wrap_CvKalman_control_matrix_set, METH_VARARGS, (char *)"CvKalman_control_matrix_set(CvKalman self, CvMat control_matrix)"},
{ (char *)"CvKalman_control_matrix_get", _wrap_CvKalman_control_matrix_get, METH_VARARGS, (char *)"CvKalman_control_matrix_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_measurement_matrix_set", _wrap_CvKalman_measurement_matrix_set, METH_VARARGS, (char *)"CvKalman_measurement_matrix_set(CvKalman self, CvMat measurement_matrix)"},
{ (char *)"CvKalman_measurement_matrix_get", _wrap_CvKalman_measurement_matrix_get, METH_VARARGS, (char *)"CvKalman_measurement_matrix_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_process_noise_cov_set", _wrap_CvKalman_process_noise_cov_set, METH_VARARGS, (char *)"CvKalman_process_noise_cov_set(CvKalman self, CvMat process_noise_cov)"},
{ (char *)"CvKalman_process_noise_cov_get", _wrap_CvKalman_process_noise_cov_get, METH_VARARGS, (char *)"CvKalman_process_noise_cov_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_measurement_noise_cov_set", _wrap_CvKalman_measurement_noise_cov_set, METH_VARARGS, (char *)"CvKalman_measurement_noise_cov_set(CvKalman self, CvMat measurement_noise_cov)"},
{ (char *)"CvKalman_measurement_noise_cov_get", _wrap_CvKalman_measurement_noise_cov_get, METH_VARARGS, (char *)"CvKalman_measurement_noise_cov_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_error_cov_pre_set", _wrap_CvKalman_error_cov_pre_set, METH_VARARGS, (char *)"CvKalman_error_cov_pre_set(CvKalman self, CvMat error_cov_pre)"},
{ (char *)"CvKalman_error_cov_pre_get", _wrap_CvKalman_error_cov_pre_get, METH_VARARGS, (char *)"CvKalman_error_cov_pre_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_gain_set", _wrap_CvKalman_gain_set, METH_VARARGS, (char *)"CvKalman_gain_set(CvKalman self, CvMat gain)"},
{ (char *)"CvKalman_gain_get", _wrap_CvKalman_gain_get, METH_VARARGS, (char *)"CvKalman_gain_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_error_cov_post_set", _wrap_CvKalman_error_cov_post_set, METH_VARARGS, (char *)"CvKalman_error_cov_post_set(CvKalman self, CvMat error_cov_post)"},
{ (char *)"CvKalman_error_cov_post_get", _wrap_CvKalman_error_cov_post_get, METH_VARARGS, (char *)"CvKalman_error_cov_post_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_temp1_set", _wrap_CvKalman_temp1_set, METH_VARARGS, (char *)"CvKalman_temp1_set(CvKalman self, CvMat temp1)"},
{ (char *)"CvKalman_temp1_get", _wrap_CvKalman_temp1_get, METH_VARARGS, (char *)"CvKalman_temp1_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_temp2_set", _wrap_CvKalman_temp2_set, METH_VARARGS, (char *)"CvKalman_temp2_set(CvKalman self, CvMat temp2)"},
{ (char *)"CvKalman_temp2_get", _wrap_CvKalman_temp2_get, METH_VARARGS, (char *)"CvKalman_temp2_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_temp3_set", _wrap_CvKalman_temp3_set, METH_VARARGS, (char *)"CvKalman_temp3_set(CvKalman self, CvMat temp3)"},
{ (char *)"CvKalman_temp3_get", _wrap_CvKalman_temp3_get, METH_VARARGS, (char *)"CvKalman_temp3_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_temp4_set", _wrap_CvKalman_temp4_set, METH_VARARGS, (char *)"CvKalman_temp4_set(CvKalman self, CvMat temp4)"},
{ (char *)"CvKalman_temp4_get", _wrap_CvKalman_temp4_get, METH_VARARGS, (char *)"CvKalman_temp4_get(CvKalman self) -> CvMat"},
{ (char *)"CvKalman_temp5_set", _wrap_CvKalman_temp5_set, METH_VARARGS, (char *)"CvKalman_temp5_set(CvKalman self, CvMat temp5)"},
{ (char *)"CvKalman_temp5_get", _wrap_CvKalman_temp5_get, METH_VARARGS, (char *)"CvKalman_temp5_get(CvKalman self) -> CvMat"},
{ (char *)"delete_CvKalman", _wrap_delete_CvKalman, METH_VARARGS, (char *)"delete_CvKalman(CvKalman self)"},
{ (char *)"CvKalman_swigregister", CvKalman_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHaarFeature_tilted_set", _wrap_CvHaarFeature_tilted_set, METH_VARARGS, (char *)"CvHaarFeature_tilted_set(CvHaarFeature self, int tilted)"},
{ (char *)"CvHaarFeature_tilted_get", _wrap_CvHaarFeature_tilted_get, METH_VARARGS, (char *)"CvHaarFeature_tilted_get(CvHaarFeature self) -> int"},
{ (char *)"CvHaarFeature_rect_get", _wrap_CvHaarFeature_rect_get, METH_VARARGS, (char *)"CvHaarFeature_rect_get(CvHaarFeature self) -> CvHaarFeature_rect"},
{ (char *)"new_CvHaarFeature", _wrap_new_CvHaarFeature, METH_VARARGS, (char *)"new_CvHaarFeature() -> CvHaarFeature"},
{ (char *)"delete_CvHaarFeature", _wrap_delete_CvHaarFeature, METH_VARARGS, (char *)"delete_CvHaarFeature(CvHaarFeature self)"},
{ (char *)"CvHaarFeature_swigregister", CvHaarFeature_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHaarFeature_rect_r_set", _wrap_CvHaarFeature_rect_r_set, METH_VARARGS, (char *)"CvHaarFeature_rect_r_set(CvHaarFeature_rect self, CvRect r)"},
{ (char *)"CvHaarFeature_rect_r_get", _wrap_CvHaarFeature_rect_r_get, METH_VARARGS, (char *)"CvHaarFeature_rect_r_get(CvHaarFeature_rect self) -> CvRect"},
{ (char *)"CvHaarFeature_rect_weight_set", _wrap_CvHaarFeature_rect_weight_set, METH_VARARGS, (char *)"CvHaarFeature_rect_weight_set(CvHaarFeature_rect self, float weight)"},
{ (char *)"CvHaarFeature_rect_weight_get", _wrap_CvHaarFeature_rect_weight_get, METH_VARARGS, (char *)"CvHaarFeature_rect_weight_get(CvHaarFeature_rect self) -> float"},
{ (char *)"new_CvHaarFeature_rect", _wrap_new_CvHaarFeature_rect, METH_VARARGS, (char *)"new_CvHaarFeature_rect() -> CvHaarFeature_rect"},
{ (char *)"delete_CvHaarFeature_rect", _wrap_delete_CvHaarFeature_rect, METH_VARARGS, (char *)"delete_CvHaarFeature_rect(CvHaarFeature_rect self)"},
{ (char *)"CvHaarFeature_rect_swigregister", CvHaarFeature_rect_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHaarClassifier_count_set", _wrap_CvHaarClassifier_count_set, METH_VARARGS, (char *)"CvHaarClassifier_count_set(CvHaarClassifier self, int count)"},
{ (char *)"CvHaarClassifier_count_get", _wrap_CvHaarClassifier_count_get, METH_VARARGS, (char *)"CvHaarClassifier_count_get(CvHaarClassifier self) -> int"},
{ (char *)"CvHaarClassifier_haar_feature_set", _wrap_CvHaarClassifier_haar_feature_set, METH_VARARGS, (char *)"CvHaarClassifier_haar_feature_set(CvHaarClassifier self, CvHaarFeature haar_feature)"},
{ (char *)"CvHaarClassifier_haar_feature_get", _wrap_CvHaarClassifier_haar_feature_get, METH_VARARGS, (char *)"CvHaarClassifier_haar_feature_get(CvHaarClassifier self) -> CvHaarFeature"},
{ (char *)"CvHaarClassifier_threshold_set", _wrap_CvHaarClassifier_threshold_set, METH_VARARGS, (char *)"CvHaarClassifier_threshold_set(CvHaarClassifier self, float threshold)"},
{ (char *)"CvHaarClassifier_threshold_get", _wrap_CvHaarClassifier_threshold_get, METH_VARARGS, (char *)"CvHaarClassifier_threshold_get(CvHaarClassifier self) -> float"},
{ (char *)"CvHaarClassifier_left_set", _wrap_CvHaarClassifier_left_set, METH_VARARGS, (char *)"CvHaarClassifier_left_set(CvHaarClassifier self, int left)"},
{ (char *)"CvHaarClassifier_left_get", _wrap_CvHaarClassifier_left_get, METH_VARARGS, (char *)"CvHaarClassifier_left_get(CvHaarClassifier self) -> int"},
{ (char *)"CvHaarClassifier_right_set", _wrap_CvHaarClassifier_right_set, METH_VARARGS, (char *)"CvHaarClassifier_right_set(CvHaarClassifier self, int right)"},
{ (char *)"CvHaarClassifier_right_get", _wrap_CvHaarClassifier_right_get, METH_VARARGS, (char *)"CvHaarClassifier_right_get(CvHaarClassifier self) -> int"},
{ (char *)"CvHaarClassifier_alpha_set", _wrap_CvHaarClassifier_alpha_set, METH_VARARGS, (char *)"CvHaarClassifier_alpha_set(CvHaarClassifier self, float alpha)"},
{ (char *)"CvHaarClassifier_alpha_get", _wrap_CvHaarClassifier_alpha_get, METH_VARARGS, (char *)"CvHaarClassifier_alpha_get(CvHaarClassifier self) -> float"},
{ (char *)"new_CvHaarClassifier", _wrap_new_CvHaarClassifier, METH_VARARGS, (char *)"new_CvHaarClassifier() -> CvHaarClassifier"},
{ (char *)"delete_CvHaarClassifier", _wrap_delete_CvHaarClassifier, METH_VARARGS, (char *)"delete_CvHaarClassifier(CvHaarClassifier self)"},
{ (char *)"CvHaarClassifier_swigregister", CvHaarClassifier_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHaarStageClassifier_count_set", _wrap_CvHaarStageClassifier_count_set, METH_VARARGS, (char *)"CvHaarStageClassifier_count_set(CvHaarStageClassifier self, int count)"},
{ (char *)"CvHaarStageClassifier_count_get", _wrap_CvHaarStageClassifier_count_get, METH_VARARGS, (char *)"CvHaarStageClassifier_count_get(CvHaarStageClassifier self) -> int"},
{ (char *)"CvHaarStageClassifier_threshold_set", _wrap_CvHaarStageClassifier_threshold_set, METH_VARARGS, (char *)"CvHaarStageClassifier_threshold_set(CvHaarStageClassifier self, float threshold)"},
{ (char *)"CvHaarStageClassifier_threshold_get", _wrap_CvHaarStageClassifier_threshold_get, METH_VARARGS, (char *)"CvHaarStageClassifier_threshold_get(CvHaarStageClassifier self) -> float"},
{ (char *)"CvHaarStageClassifier_classifier_set", _wrap_CvHaarStageClassifier_classifier_set, METH_VARARGS, (char *)"CvHaarStageClassifier_classifier_set(CvHaarStageClassifier self, CvHaarClassifier classifier)"},
{ (char *)"CvHaarStageClassifier_classifier_get", _wrap_CvHaarStageClassifier_classifier_get, METH_VARARGS, (char *)"CvHaarStageClassifier_classifier_get(CvHaarStageClassifier self) -> CvHaarClassifier"},
{ (char *)"CvHaarStageClassifier_next_set", _wrap_CvHaarStageClassifier_next_set, METH_VARARGS, (char *)"CvHaarStageClassifier_next_set(CvHaarStageClassifier self, int next)"},
{ (char *)"CvHaarStageClassifier_next_get", _wrap_CvHaarStageClassifier_next_get, METH_VARARGS, (char *)"CvHaarStageClassifier_next_get(CvHaarStageClassifier self) -> int"},
{ (char *)"CvHaarStageClassifier_child_set", _wrap_CvHaarStageClassifier_child_set, METH_VARARGS, (char *)"CvHaarStageClassifier_child_set(CvHaarStageClassifier self, int child)"},
{ (char *)"CvHaarStageClassifier_child_get", _wrap_CvHaarStageClassifier_child_get, METH_VARARGS, (char *)"CvHaarStageClassifier_child_get(CvHaarStageClassifier self) -> int"},
{ (char *)"CvHaarStageClassifier_parent_set", _wrap_CvHaarStageClassifier_parent_set, METH_VARARGS, (char *)"CvHaarStageClassifier_parent_set(CvHaarStageClassifier self, int parent)"},
{ (char *)"CvHaarStageClassifier_parent_get", _wrap_CvHaarStageClassifier_parent_get, METH_VARARGS, (char *)"CvHaarStageClassifier_parent_get(CvHaarStageClassifier self) -> int"},
{ (char *)"new_CvHaarStageClassifier", _wrap_new_CvHaarStageClassifier, METH_VARARGS, (char *)"new_CvHaarStageClassifier() -> CvHaarStageClassifier"},
{ (char *)"delete_CvHaarStageClassifier", _wrap_delete_CvHaarStageClassifier, METH_VARARGS, (char *)"delete_CvHaarStageClassifier(CvHaarStageClassifier self)"},
{ (char *)"CvHaarStageClassifier_swigregister", CvHaarStageClassifier_swigregister, METH_VARARGS, NULL},
{ (char *)"CvHaarClassifierCascade_flags_set", _wrap_CvHaarClassifierCascade_flags_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_flags_set(CvHaarClassifierCascade self, int flags)"},
{ (char *)"CvHaarClassifierCascade_flags_get", _wrap_CvHaarClassifierCascade_flags_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_flags_get(CvHaarClassifierCascade self) -> int"},
{ (char *)"CvHaarClassifierCascade_count_set", _wrap_CvHaarClassifierCascade_count_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_count_set(CvHaarClassifierCascade self, int count)"},
{ (char *)"CvHaarClassifierCascade_count_get", _wrap_CvHaarClassifierCascade_count_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_count_get(CvHaarClassifierCascade self) -> int"},
{ (char *)"CvHaarClassifierCascade_orig_window_size_set", _wrap_CvHaarClassifierCascade_orig_window_size_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_orig_window_size_set(CvHaarClassifierCascade self, CvSize orig_window_size)"},
{ (char *)"CvHaarClassifierCascade_orig_window_size_get", _wrap_CvHaarClassifierCascade_orig_window_size_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_orig_window_size_get(CvHaarClassifierCascade self) -> CvSize"},
{ (char *)"CvHaarClassifierCascade_real_window_size_set", _wrap_CvHaarClassifierCascade_real_window_size_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_real_window_size_set(CvHaarClassifierCascade self, CvSize real_window_size)"},
{ (char *)"CvHaarClassifierCascade_real_window_size_get", _wrap_CvHaarClassifierCascade_real_window_size_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_real_window_size_get(CvHaarClassifierCascade self) -> CvSize"},
{ (char *)"CvHaarClassifierCascade_scale_set", _wrap_CvHaarClassifierCascade_scale_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_scale_set(CvHaarClassifierCascade self, double scale)"},
{ (char *)"CvHaarClassifierCascade_scale_get", _wrap_CvHaarClassifierCascade_scale_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_scale_get(CvHaarClassifierCascade self) -> double"},
{ (char *)"CvHaarClassifierCascade_stage_classifier_set", _wrap_CvHaarClassifierCascade_stage_classifier_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_stage_classifier_set(CvHaarClassifierCascade self, CvHaarStageClassifier stage_classifier)"},
{ (char *)"CvHaarClassifierCascade_stage_classifier_get", _wrap_CvHaarClassifierCascade_stage_classifier_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_stage_classifier_get(CvHaarClassifierCascade self) -> CvHaarStageClassifier"},
{ (char *)"CvHaarClassifierCascade_hid_cascade_set", _wrap_CvHaarClassifierCascade_hid_cascade_set, METH_VARARGS, (char *)"CvHaarClassifierCascade_hid_cascade_set(CvHaarClassifierCascade self, CvHidHaarClassifierCascade hid_cascade)"},
{ (char *)"CvHaarClassifierCascade_hid_cascade_get", _wrap_CvHaarClassifierCascade_hid_cascade_get, METH_VARARGS, (char *)"CvHaarClassifierCascade_hid_cascade_get(CvHaarClassifierCascade self) -> CvHidHaarClassifierCascade"},
{ (char *)"delete_CvHaarClassifierCascade", _wrap_delete_CvHaarClassifierCascade, METH_VARARGS, (char *)"delete_CvHaarClassifierCascade(CvHaarClassifierCascade self)"},
{ (char *)"CvHaarClassifierCascade_swigregister", CvHaarClassifierCascade_swigregister, METH_VARARGS, NULL},
{ (char *)"CvAvgComp_rect_set", _wrap_CvAvgComp_rect_set, METH_VARARGS, (char *)"CvAvgComp_rect_set(CvAvgComp self, CvRect rect)"},
{ (char *)"CvAvgComp_rect_get", _wrap_CvAvgComp_rect_get, METH_VARARGS, (char *)"CvAvgComp_rect_get(CvAvgComp self) -> CvRect"},
{ (char *)"CvAvgComp_neighbors_set", _wrap_CvAvgComp_neighbors_set, METH_VARARGS, (char *)"CvAvgComp_neighbors_set(CvAvgComp self, int neighbors)"},
{ (char *)"CvAvgComp_neighbors_get", _wrap_CvAvgComp_neighbors_get, METH_VARARGS, (char *)"CvAvgComp_neighbors_get(CvAvgComp self) -> int"},
{ (char *)"new_CvAvgComp", _wrap_new_CvAvgComp, METH_VARARGS, (char *)"new_CvAvgComp() -> CvAvgComp"},
{ (char *)"delete_CvAvgComp", _wrap_delete_CvAvgComp, METH_VARARGS, (char *)"delete_CvAvgComp(CvAvgComp self)"},
{ (char *)"CvAvgComp_swigregister", CvAvgComp_swigregister, METH_VARARGS, NULL},
{ (char *)"cvCopyMakeBorder", _wrap_cvCopyMakeBorder, METH_VARARGS, (char *)"\n"
"cvCopyMakeBorder(CvArr src, CvArr dst, CvPoint offset, int bordertype, \n"
" CvScalar value=cvScalarAll(0))\n"
""},
{ (char *)"cvSmooth", _wrap_cvSmooth, METH_VARARGS, (char *)"\n"
"cvSmooth(CvArr src, CvArr dst, int smoothtype=2, int size1=3, \n"
" int size2=0, double sigma1=0, double sigma2=0)\n"
""},
{ (char *)"cvFilter2D", _wrap_cvFilter2D, METH_VARARGS, (char *)"cvFilter2D(CvArr src, CvArr dst, CvMat kernel, CvPoint anchor=cvPoint(-1,-1))"},
{ (char *)"cvIntegral", _wrap_cvIntegral, METH_VARARGS, (char *)"cvIntegral(CvArr image, CvArr sum, CvArr sqsum=None, CvArr tilted_sum=None)"},
{ (char *)"cvPyrDown", _wrap_cvPyrDown, METH_VARARGS, (char *)"cvPyrDown(CvArr src, CvArr dst, int filter=CV_GAUSSIAN_5x5)"},
{ (char *)"cvPyrUp", _wrap_cvPyrUp, METH_VARARGS, (char *)"cvPyrUp(CvArr src, CvArr dst, int filter=CV_GAUSSIAN_5x5)"},
{ (char *)"cvCreatePyramid", _wrap_cvCreatePyramid, METH_VARARGS, (char *)"\n"
"cvCreatePyramid(CvArr img, int extra_layers, double rate, CvSize layer_sizes=0, \n"
" CvArr bufarr=0, int calc=1, int filter=CV_GAUSSIAN_5x5) -> CvMat\n"
""},
{ (char *)"cvReleasePyramid", _wrap_cvReleasePyramid, METH_VARARGS, (char *)"cvReleasePyramid(CvMat pyramid, int extra_layers)"},
{ (char *)"cvPyrSegmentationUntyped", _wrap_cvPyrSegmentationUntyped, METH_VARARGS, (char *)"\n"
"cvPyrSegmentationUntyped( src, dst, CvMemStorage storage, CvSeq comp, int level, \n"
" double threshold1, double threshold2)\n"
""},
{ (char *)"cvPyrMeanShiftFiltering", _wrap_cvPyrMeanShiftFiltering, METH_VARARGS, (char *)"\n"
"cvPyrMeanShiftFiltering(CvArr src, CvArr dst, double sp, double sr, int max_level=1, \n"
" CvTermCriteria termcrit=cvTermCriteria(1 +2,5,1))\n"
""},
{ (char *)"cvWatershed", _wrap_cvWatershed, METH_VARARGS, (char *)"cvWatershed(CvArr image, CvArr markers)"},
{ (char *)"cvInpaint", _wrap_cvInpaint, METH_VARARGS, (char *)"\n"
"cvInpaint(CvArr src, CvArr inpaint_mask, CvArr dst, double inpaintRange, \n"
" int flags)\n"
""},
{ (char *)"cvSobel", _wrap_cvSobel, METH_VARARGS, (char *)"cvSobel(CvArr src, CvArr dst, int xorder, int yorder, int aperture_size=3)"},
{ (char *)"cvLaplace", _wrap_cvLaplace, METH_VARARGS, (char *)"cvLaplace(CvArr src, CvArr dst, int aperture_size=3)"},
{ (char *)"cvCvtColor", _wrap_cvCvtColor, METH_VARARGS, (char *)"cvCvtColor(CvArr src, CvArr dst, int code)"},
{ (char *)"cvResize", _wrap_cvResize, METH_VARARGS, (char *)"cvResize(CvArr src, CvArr dst, int interpolation=1)"},
{ (char *)"cvWarpAffine", _wrap_cvWarpAffine, METH_VARARGS, (char *)"\n"
"cvWarpAffine(CvArr src, CvArr dst, CvMat map_matrix, int flags=1+8, \n"
" CvScalar fillval=cvScalarAll(0))\n"
""},
{ (char *)"cvGetAffineTransform", _wrap_cvGetAffineTransform, METH_VARARGS, (char *)"cvGetAffineTransform(CvPoint2D32f src, CvPoint2D32f dst, CvMat map_matrix) -> CvMat"},
{ (char *)"cv2DRotationMatrix", _wrap_cv2DRotationMatrix, METH_VARARGS, (char *)"cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale, CvMat map_matrix) -> CvMat"},
{ (char *)"cvWarpPerspective", _wrap_cvWarpPerspective, METH_VARARGS, (char *)"\n"
"cvWarpPerspective(CvArr src, CvArr dst, CvMat map_matrix, int flags=1+8, \n"
" CvScalar fillval=cvScalarAll(0))\n"
""},
{ (char *)"cvGetPerspectiveTransform", _wrap_cvGetPerspectiveTransform, METH_VARARGS, (char *)"cvGetPerspectiveTransform(CvPoint2D32f src, CvPoint2D32f dst, CvMat map_matrix) -> CvMat"},
{ (char *)"cvRemap", _wrap_cvRemap, METH_VARARGS, (char *)"\n"
"cvRemap(CvArr src, CvArr dst, CvArr mapx, CvArr mapy, int flags=1+8, \n"
" CvScalar fillval=cvScalarAll(0))\n"
""},
{ (char *)"cvConvertMaps", _wrap_cvConvertMaps, METH_VARARGS, (char *)"cvConvertMaps(CvArr mapx, CvArr mapy, CvArr mapxy, CvArr mapalpha)"},
{ (char *)"cvLogPolar", _wrap_cvLogPolar, METH_VARARGS, (char *)"\n"
"cvLogPolar(CvArr src, CvArr dst, CvPoint2D32f center, double M, \n"
" int flags=1+8)\n"
""},
{ (char *)"cvCreateStructuringElementEx", _wrap_cvCreateStructuringElementEx, METH_VARARGS, (char *)"\n"
"cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, \n"
" int values=None)\n"
""},
{ (char *)"cvErode", _wrap_cvErode, METH_VARARGS, (char *)"cvErode(CvArr src, CvArr dst, element=None, int iterations=1)"},
{ (char *)"cvDilate", _wrap_cvDilate, METH_VARARGS, (char *)"cvDilate(CvArr src, CvArr dst, element=None, int iterations=1)"},
{ (char *)"cvMorphologyEx", _wrap_cvMorphologyEx, METH_VARARGS, (char *)"\n"
"cvMorphologyEx(CvArr src, CvArr dst, CvArr temp, element, int operation, \n"
" int iterations=1)\n"
""},
{ (char *)"cvMoments", _wrap_cvMoments, METH_VARARGS, (char *)"cvMoments(CvArr arr, CvMoments moments, int binary=0)"},
{ (char *)"cvGetSpatialMoment", _wrap_cvGetSpatialMoment, METH_VARARGS, (char *)"cvGetSpatialMoment(CvMoments moments, int x_order, int y_order) -> double"},
{ (char *)"cvGetCentralMoment", _wrap_cvGetCentralMoment, METH_VARARGS, (char *)"cvGetCentralMoment(CvMoments moments, int x_order, int y_order) -> double"},
{ (char *)"cvGetNormalizedCentralMoment", _wrap_cvGetNormalizedCentralMoment, METH_VARARGS, (char *)"cvGetNormalizedCentralMoment(CvMoments moments, int x_order, int y_order) -> double"},
{ (char *)"cvGetHuMoments", _wrap_cvGetHuMoments, METH_VARARGS, (char *)"cvGetHuMoments(CvMoments moments, CvHuMoments hu_moments)"},
{ (char *)"cvSampleLine", _wrap_cvSampleLine, METH_VARARGS, (char *)"\n"
"cvSampleLine(CvArr image, CvPoint pt1, CvPoint pt2, void buffer, \n"
" int connectivity=8) -> int\n"
""},
{ (char *)"cvGetRectSubPix", _wrap_cvGetRectSubPix, METH_VARARGS, (char *)"cvGetRectSubPix(CvArr src, CvArr dst, CvPoint2D32f center)"},
{ (char *)"cvGetQuadrangleSubPix", _wrap_cvGetQuadrangleSubPix, METH_VARARGS, (char *)"cvGetQuadrangleSubPix(CvArr src, CvArr dst, CvMat map_matrix)"},
{ (char *)"cvMatchTemplate", _wrap_cvMatchTemplate, METH_VARARGS, (char *)"cvMatchTemplate(CvArr image, CvArr templ, CvArr result, int method)"},
{ (char *)"cvCalcEMD2", _wrap_cvCalcEMD2, METH_VARARGS, (char *)"\n"
"cvCalcEMD2(CvArr signature1, CvArr signature2, int distance_type, \n"
" CvDistanceFunction distance_func=None, CvArr cost_matrix=None, \n"
" CvArr flow=None, float lower_bound=None, \n"
" void userdata=None) -> float\n"
""},
{ (char *)"cvFindContoursUntyped", _wrap_cvFindContoursUntyped, METH_VARARGS, (char *)"\n"
"cvFindContoursUntyped(CvArr image, CvMemStorage storage, CvSeq first_contour, \n"
" int header_size=sizeof(CvContour), int mode=1, \n"
" int method=2, CvPoint offset=cvPoint(0,0)) -> int\n"
""},
{ (char *)"cvStartFindContours", _wrap_cvStartFindContours, METH_VARARGS, (char *)"\n"
"cvStartFindContours(CvArr image, CvMemStorage storage, int header_size=sizeof(CvContour), \n"
" int mode=1, int method=2, \n"
" CvPoint offset=cvPoint(0,0)) -> CvContourScanner\n"
""},
{ (char *)"cvFindNextContour", _wrap_cvFindNextContour, METH_VARARGS, (char *)"cvFindNextContour(CvContourScanner scanner) -> CvSeq"},
{ (char *)"cvSubstituteContour", _wrap_cvSubstituteContour, METH_VARARGS, (char *)"cvSubstituteContour(CvContourScanner scanner, CvSeq new_contour)"},
{ (char *)"cvEndFindContours", _wrap_cvEndFindContours, METH_VARARGS, (char *)"cvEndFindContours(CvContourScanner scanner) -> CvSeq"},
{ (char *)"cvApproxChainsUntyped", _wrap_cvApproxChainsUntyped, METH_VARARGS, (char *)"\n"
"cvApproxChainsUntyped(CvSeq src_seq, CvMemStorage storage, int method=2, \n"
" double parameter=0, int minimal_perimeter=0, \n"
" int recursive=0) -> CvSeq\n"
""},
{ (char *)"cvStartReadChainPoints", _wrap_cvStartReadChainPoints, METH_VARARGS, (char *)"cvStartReadChainPoints(CvChain chain, CvChainPtReader reader)"},
{ (char *)"cvReadChainPoint", _wrap_cvReadChainPoint, METH_VARARGS, (char *)"cvReadChainPoint(CvChainPtReader reader) -> CvPoint"},
{ (char *)"cvCalcOpticalFlowLK", _wrap_cvCalcOpticalFlowLK, METH_VARARGS, (char *)"\n"
"cvCalcOpticalFlowLK(CvArr prev, CvArr curr, CvSize win_size, CvArr velx, \n"
" CvArr vely)\n"
""},
{ (char *)"cvCalcOpticalFlowBM", _wrap_cvCalcOpticalFlowBM, METH_VARARGS, (char *)"\n"
"cvCalcOpticalFlowBM(CvArr prev, CvArr curr, CvSize block_size, CvSize shift_size, \n"
" CvSize max_range, int use_previous, \n"
" CvArr velx, CvArr vely)\n"
""},
{ (char *)"cvCalcOpticalFlowHS", _wrap_cvCalcOpticalFlowHS, METH_VARARGS, (char *)"\n"
"cvCalcOpticalFlowHS(CvArr prev, CvArr curr, int use_previous, CvArr velx, \n"
" CvArr vely, double lambda, CvTermCriteria criteria)\n"
""},
{ (char *)"cvCalcOpticalFlowPyrLK", _wrap_cvCalcOpticalFlowPyrLK, METH_VARARGS, (char *)"\n"
"cvCalcOpticalFlowPyrLK(CvArr prev, CvArr curr, CvArr prev_pyr, CvArr curr_pyr, \n"
" CvPoint2D32f prev_features, CvPoint2D32f curr_features, \n"
" CvSize win_size, int level, char status, \n"
" float track_error, CvTermCriteria criteria, \n"
" int flags)\n"
""},
{ (char *)"cvCalcAffineFlowPyrLK", _wrap_cvCalcAffineFlowPyrLK, METH_VARARGS, (char *)"\n"
"cvCalcAffineFlowPyrLK(CvArr prev, CvArr curr, CvArr prev_pyr, CvArr curr_pyr, \n"
" CvPoint2D32f prev_features, CvPoint2D32f curr_features, \n"
" float matrices, int count, CvSize win_size, \n"
" int level, char status, float track_error, \n"
" CvTermCriteria criteria, int flags)\n"
""},
{ (char *)"cvEstimateRigidTransform", _wrap_cvEstimateRigidTransform, METH_VARARGS, (char *)"cvEstimateRigidTransform(CvArr A, CvArr B, CvMat M, int full_affine) -> int"},
{ (char *)"cvUpdateMotionHistory", _wrap_cvUpdateMotionHistory, METH_VARARGS, (char *)"cvUpdateMotionHistory(CvArr silhouette, CvArr mhi, double timestamp, double duration)"},
{ (char *)"cvCalcMotionGradient", _wrap_cvCalcMotionGradient, METH_VARARGS, (char *)"\n"
"cvCalcMotionGradient(CvArr mhi, CvArr mask, CvArr orientation, double delta1, \n"
" double delta2, int aperture_size=3)\n"
""},
{ (char *)"cvCalcGlobalOrientation", _wrap_cvCalcGlobalOrientation, METH_VARARGS, (char *)"\n"
"cvCalcGlobalOrientation(CvArr orientation, CvArr mask, CvArr mhi, double timestamp, \n"
" double duration) -> double\n"
""},
{ (char *)"cvAcc", _wrap_cvAcc, METH_VARARGS, (char *)"cvAcc(CvArr image, CvArr sum, CvArr mask=None)"},
{ (char *)"cvSquareAcc", _wrap_cvSquareAcc, METH_VARARGS, (char *)"cvSquareAcc(CvArr image, CvArr sqsum, CvArr mask=None)"},
{ (char *)"cvMultiplyAcc", _wrap_cvMultiplyAcc, METH_VARARGS, (char *)"cvMultiplyAcc(CvArr image1, CvArr image2, CvArr acc, CvArr mask=None)"},
{ (char *)"cvRunningAvg", _wrap_cvRunningAvg, METH_VARARGS, (char *)"cvRunningAvg(CvArr image, CvArr acc, double alpha, CvArr mask=None)"},
{ (char *)"cvCamShift", _wrap_cvCamShift, METH_VARARGS, (char *)"\n"
"cvCamShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, \n"
" CvConnectedComp comp, CvBox2D box=None) -> int\n"
""},
{ (char *)"cvMeanShift", _wrap_cvMeanShift, METH_VARARGS, (char *)"\n"
"cvMeanShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, \n"
" CvConnectedComp comp) -> int\n"
""},
{ (char *)"cvCreateConDensation", _wrap_cvCreateConDensation, METH_VARARGS, (char *)"cvCreateConDensation(int dynam_params, int measure_params, int sample_count) -> CvConDensation"},
{ (char *)"cvConDensUpdateByTime", _wrap_cvConDensUpdateByTime, METH_VARARGS, (char *)"cvConDensUpdateByTime(CvConDensation condens)"},
{ (char *)"cvConDensInitSampleSet", _wrap_cvConDensInitSampleSet, METH_VARARGS, (char *)"cvConDensInitSampleSet(CvConDensation condens, CvMat lower_bound, CvMat upper_bound)"},
{ (char *)"cvCreateKalman", _wrap_cvCreateKalman, METH_VARARGS, (char *)"cvCreateKalman(int dynam_params, int measure_params, int control_params=0) -> CvKalman"},
{ (char *)"cvKalmanPredict", _wrap_cvKalmanPredict, METH_VARARGS, (char *)"cvKalmanPredict(CvKalman kalman, CvMat control=None) -> CvMat"},
{ (char *)"cvKalmanCorrect", _wrap_cvKalmanCorrect, METH_VARARGS, (char *)"cvKalmanCorrect(CvKalman kalman, CvMat measurement) -> CvMat"},
{ (char *)"cvInitSubdivDelaunay2D", _wrap_cvInitSubdivDelaunay2D, METH_VARARGS, (char *)"cvInitSubdivDelaunay2D(CvSubdiv2D subdiv, CvRect rect)"},
{ (char *)"cvCreateSubdiv2D", _wrap_cvCreateSubdiv2D, METH_VARARGS, (char *)"\n"
"cvCreateSubdiv2D(int subdiv_type, int header_size, int vtx_size, int quadedge_size, \n"
" CvMemStorage storage) -> CvSubdiv2D\n"
""},
{ (char *)"cvCreateSubdivDelaunay2D", _wrap_cvCreateSubdivDelaunay2D, METH_VARARGS, (char *)"cvCreateSubdivDelaunay2D(CvRect rect, CvMemStorage storage) -> CvSubdiv2D"},
{ (char *)"cvSubdivDelaunay2DInsert", _wrap_cvSubdivDelaunay2DInsert, METH_VARARGS, (char *)"cvSubdivDelaunay2DInsert(CvSubdiv2D subdiv, CvPoint2D32f pt) -> CvSubdiv2DPoint"},
{ (char *)"cvSubdiv2DLocate", _wrap_cvSubdiv2DLocate, METH_VARARGS, (char *)"cvSubdiv2DLocate(CvSubdiv2D subdiv, CvPoint2D32f pt, CvSubdiv2DEdge edge) -> CvSubdiv2DPointLocation"},
{ (char *)"cvCalcSubdivVoronoi2D", _wrap_cvCalcSubdivVoronoi2D, METH_VARARGS, (char *)"cvCalcSubdivVoronoi2D(CvSubdiv2D subdiv)"},
{ (char *)"cvClearSubdivVoronoi2D", _wrap_cvClearSubdivVoronoi2D, METH_VARARGS, (char *)"cvClearSubdivVoronoi2D(CvSubdiv2D subdiv)"},
{ (char *)"cvFindNearestPoint2D", _wrap_cvFindNearestPoint2D, METH_VARARGS, (char *)"cvFindNearestPoint2D(CvSubdiv2D subdiv, CvPoint2D32f pt) -> CvSubdiv2DPoint"},
{ (char *)"cvSubdiv2DNextEdge", _wrap_cvSubdiv2DNextEdge, METH_VARARGS, (char *)"cvSubdiv2DNextEdge(CvSubdiv2DEdge edge) -> CvSubdiv2DEdge"},
{ (char *)"cvSubdiv2DRotateEdge", _wrap_cvSubdiv2DRotateEdge, METH_VARARGS, (char *)"cvSubdiv2DRotateEdge(CvSubdiv2DEdge edge, int rotate) -> CvSubdiv2DEdge"},
{ (char *)"cvSubdiv2DSymEdge", _wrap_cvSubdiv2DSymEdge, METH_VARARGS, (char *)"cvSubdiv2DSymEdge(CvSubdiv2DEdge edge) -> CvSubdiv2DEdge"},
{ (char *)"cvSubdiv2DGetEdge", _wrap_cvSubdiv2DGetEdge, METH_VARARGS, (char *)"cvSubdiv2DGetEdge(CvSubdiv2DEdge edge, CvNextEdgeType type) -> CvSubdiv2DEdge"},
{ (char *)"cvSubdiv2DEdgeOrg", _wrap_cvSubdiv2DEdgeOrg, METH_VARARGS, (char *)"cvSubdiv2DEdgeOrg(CvSubdiv2DEdge edge) -> CvSubdiv2DPoint"},
{ (char *)"cvSubdiv2DEdgeDst", _wrap_cvSubdiv2DEdgeDst, METH_VARARGS, (char *)"cvSubdiv2DEdgeDst(CvSubdiv2DEdge edge) -> CvSubdiv2DPoint"},
{ (char *)"cvTriangleArea", _wrap_cvTriangleArea, METH_VARARGS, (char *)"cvTriangleArea(CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c) -> double"},
{ (char *)"cvFindDominantPoints", _wrap_cvFindDominantPoints, METH_VARARGS, (char *)"\n"
"cvFindDominantPoints(CvSeq contour, CvMemStorage storage, int method=1, \n"
" double parameter1=0, double parameter2=0, double parameter3=0, \n"
" double parameter4=0) -> CvSeq\n"
""},
{ (char *)"cvBoundingRect", _wrap_cvBoundingRect, METH_VARARGS, (char *)"cvBoundingRect(CvArr points, int update=0) -> CvRect"},
{ (char *)"cvContourArea", _wrap_cvContourArea, METH_VARARGS, (char *)"cvContourArea(CvArr contour, CvSlice slice=cvSlice(0, 0x3fffffff)) -> double"},
{ (char *)"cvMinAreaRect2", _wrap_cvMinAreaRect2, METH_VARARGS, (char *)"cvMinAreaRect2(CvArr points, CvMemStorage storage=None) -> CvBox2D"},
{ (char *)"cvMinEnclosingCircle", _wrap_cvMinEnclosingCircle, METH_VARARGS, (char *)"cvMinEnclosingCircle(CvArr points, CvPoint2D32f center) -> int"},
{ (char *)"cvMatchShapes", _wrap_cvMatchShapes, METH_VARARGS, (char *)"cvMatchShapes(void object1, void object2, int method, double parameter=0) -> double"},
{ (char *)"cvCreateContourTree", _wrap_cvCreateContourTree, METH_VARARGS, (char *)"cvCreateContourTree(CvSeq contour, CvMemStorage storage, double threshold) -> CvContourTree"},
{ (char *)"cvContourFromContourTreeUntyped", _wrap_cvContourFromContourTreeUntyped, METH_VARARGS, (char *)"cvContourFromContourTreeUntyped(CvContourTree tree, CvMemStorage storage, CvTermCriteria criteria) -> CvSeq"},
{ (char *)"cvMatchContourTrees", _wrap_cvMatchContourTrees, METH_VARARGS, (char *)"\n"
"cvMatchContourTrees(CvContourTree tree1, CvContourTree tree2, int method, \n"
" double threshold) -> double\n"
""},
{ (char *)"cvCalcPGH", _wrap_cvCalcPGH, METH_VARARGS, (char *)"cvCalcPGH(CvSeq contour, CvHistogram hist)"},
{ (char *)"cvCheckContourConvexity", _wrap_cvCheckContourConvexity, METH_VARARGS, (char *)"cvCheckContourConvexity(CvArr contour) -> int"},
{ (char *)"cvConvexityDefectsUntyped", _wrap_cvConvexityDefectsUntyped, METH_VARARGS, (char *)"cvConvexityDefectsUntyped(CvArr contour, CvArr convexhull, CvMemStorage storage=None) -> CvSeq"},
{ (char *)"cvFitEllipse2", _wrap_cvFitEllipse2, METH_VARARGS, (char *)"cvFitEllipse2(CvArr points) -> CvBox2D"},
{ (char *)"cvMaxRect", _wrap_cvMaxRect, METH_VARARGS, (char *)"cvMaxRect(CvRect rect1, CvRect rect2) -> CvRect"},
{ (char *)"cvBoxPoints", _wrap_cvBoxPoints, METH_VARARGS, (char *)"cvBoxPoints(CvBox2D box, CvPoint2D32f pt)"},
{ (char *)"cvPointSeqFromMat", _wrap_cvPointSeqFromMat, METH_VARARGS, (char *)"\n"
"cvPointSeqFromMat(int seq_kind, CvArr mat, CvContour contour_header, \n"
" CvSeqBlock block) -> CvSeq\n"
""},
{ (char *)"cvPointPolygonTest", _wrap_cvPointPolygonTest, METH_VARARGS, (char *)"cvPointPolygonTest(CvArr contour, CvPoint2D32f pt, int measure_dist) -> double"},
{ (char *)"cvCreateHist", _wrap_cvCreateHist, METH_VARARGS, (char *)"cvCreateHist(int dims, int type, float ranges=None, int uniform=1) -> CvHistogram"},
{ (char *)"cvSetHistBinRanges", _wrap_cvSetHistBinRanges, METH_VARARGS, (char *)"cvSetHistBinRanges(CvHistogram hist, float ranges, int uniform=1)"},
{ (char *)"cvMakeHistHeaderForArray", _wrap_cvMakeHistHeaderForArray, METH_VARARGS, (char *)"\n"
"cvMakeHistHeaderForArray(int dims, CvHistogram hist, float data, float ranges=None, \n"
" int uniform=1) -> CvHistogram\n"
""},
{ (char *)"cvClearHist", _wrap_cvClearHist, METH_VARARGS, (char *)"cvClearHist(CvHistogram hist)"},
{ (char *)"cvGetMinMaxHistValue", _wrap_cvGetMinMaxHistValue, METH_VARARGS, (char *)"\n"
"cvGetMinMaxHistValue(CvHistogram hist, float min_value, float max_value, \n"
" int min_idx=None, int max_idx=None)\n"
""},
{ (char *)"cvNormalizeHist", _wrap_cvNormalizeHist, METH_VARARGS, (char *)"cvNormalizeHist(CvHistogram hist, double factor)"},
{ (char *)"cvThreshHist", _wrap_cvThreshHist, METH_VARARGS, (char *)"cvThreshHist(CvHistogram hist, double threshold)"},
{ (char *)"cvCompareHist", _wrap_cvCompareHist, METH_VARARGS, (char *)"cvCompareHist(CvHistogram hist1, CvHistogram hist2, int method) -> double"},
{ (char *)"cvCopyHist", _wrap_cvCopyHist, METH_VARARGS, (char *)"cvCopyHist(CvHistogram src, CvHistogram dst)"},
{ (char *)"cvCalcBayesianProb", _wrap_cvCalcBayesianProb, METH_VARARGS, (char *)"cvCalcBayesianProb(CvHistogram src, int number, CvHistogram dst)"},
{ (char *)"cvCalcArrHist", _wrap_cvCalcArrHist, METH_VARARGS, (char *)"cvCalcArrHist(CvArr arr, CvHistogram hist, int accumulate=0, CvArr mask=None)"},
{ (char *)"cvCalcImageHist", _wrap_cvCalcImageHist, METH_VARARGS, (char *)"cvCalcImageHist( image, CvHistogram hist, int accumulate=0, CvArr mask=None)"},
{ (char *)"cvCalcArrBackProject", _wrap_cvCalcArrBackProject, METH_VARARGS, (char *)"cvCalcArrBackProject(CvArr image, CvArr dst, CvHistogram hist)"},
{ (char *)"cvCalcArrBackProjectPatch", _wrap_cvCalcArrBackProjectPatch, METH_VARARGS, (char *)"\n"
"cvCalcArrBackProjectPatch(CvArr image, CvArr dst, CvSize range, CvHistogram hist, \n"
" int method, double factor)\n"
""},
{ (char *)"cvCalcProbDensity", _wrap_cvCalcProbDensity, METH_VARARGS, (char *)"\n"
"cvCalcProbDensity(CvHistogram hist1, CvHistogram hist2, CvHistogram dst_hist, \n"
" double scale=255)\n"
""},
{ (char *)"cvEqualizeHist", _wrap_cvEqualizeHist, METH_VARARGS, (char *)"cvEqualizeHist(CvArr src, CvArr dst)"},
{ (char *)"cvCalcImageHomography", _wrap_cvCalcImageHomography, METH_VARARGS, (char *)"cvCalcImageHomography(float line, CvPoint3D32f center, float intrinsic, float homography)"},
{ (char *)"cvDistTransform", _wrap_cvDistTransform, METH_VARARGS, (char *)"\n"
"cvDistTransform(CvArr src, CvArr dst, int distance_type=2, int mask_size=3, \n"
" float mask=None, CvArr labels=None)\n"
""},
{ (char *)"cvThreshold", _wrap_cvThreshold, METH_VARARGS, (char *)"\n"
"cvThreshold(CvArr src, CvArr dst, double threshold, double max_value, \n"
" int threshold_type) -> double\n"
""},
{ (char *)"cvAdaptiveThreshold", _wrap_cvAdaptiveThreshold, METH_VARARGS, (char *)"\n"
"cvAdaptiveThreshold(CvArr src, CvArr dst, double max_value, int adaptive_method=0, \n"
" int threshold_type=0, int block_size=3, \n"
" double param1=5)\n"
""},
{ (char *)"cvFloodFill", _wrap_cvFloodFill, METH_VARARGS, (char *)"\n"
"cvFloodFill(CvArr image, CvPoint seed_point, CvScalar new_val, \n"
" CvScalar lo_diff=cvScalarAll(0), CvScalar up_diff=cvScalarAll(0), \n"
" CvConnectedComp comp=None, \n"
" int flags=4, CvArr mask=None)\n"
""},
{ (char *)"cvCanny", _wrap_cvCanny, METH_VARARGS, (char *)"\n"
"cvCanny(CvArr image, CvArr edges, double threshold1, double threshold2, \n"
" int aperture_size=3)\n"
""},
{ (char *)"cvPreCornerDetect", _wrap_cvPreCornerDetect, METH_VARARGS, (char *)"cvPreCornerDetect(CvArr image, CvArr corners, int aperture_size=3)"},
{ (char *)"cvCornerEigenValsAndVecs", _wrap_cvCornerEigenValsAndVecs, METH_VARARGS, (char *)"cvCornerEigenValsAndVecs(CvArr image, CvArr eigenvv, int block_size, int aperture_size=3)"},
{ (char *)"cvCornerMinEigenVal", _wrap_cvCornerMinEigenVal, METH_VARARGS, (char *)"cvCornerMinEigenVal(CvArr image, CvArr eigenval, int block_size, int aperture_size=3)"},
{ (char *)"cvCornerHarris", _wrap_cvCornerHarris, METH_VARARGS, (char *)"\n"
"cvCornerHarris(CvArr image, CvArr harris_responce, int block_size, \n"
" int aperture_size=3, double k=0.04)\n"
""},
{ (char *)"cvFindCornerSubPix", _wrap_cvFindCornerSubPix, METH_VARARGS, (char *)"\n"
"cvFindCornerSubPix(CvArr image, CvPoint2D32f corners, CvSize win, CvSize zero_zone, \n"
" CvTermCriteria criteria)\n"
""},
{ (char *)"cvGoodFeaturesToTrack", _wrap_cvGoodFeaturesToTrack, METH_VARARGS, (char *)"\n"
"cvGoodFeaturesToTrack(CvArr image, CvArr eig_image, CvArr temp_image, CvPoint2D32f corners, \n"
" double quality_level, double min_distance, \n"
" CvArr mask=None, int block_size=3, \n"
" int use_harris=0, double k=0.04)\n"
""},
{ (char *)"cvHoughLinesUntyped", _wrap_cvHoughLinesUntyped, METH_VARARGS, (char *)"\n"
"cvHoughLinesUntyped(CvArr image, void line_storage, int method, double rho, \n"
" double theta, int threshold, double param1=0, \n"
" double param2=0) -> CvSeq\n"
""},
{ (char *)"cvHoughCirclesUntyped", _wrap_cvHoughCirclesUntyped, METH_VARARGS, (char *)"\n"
"cvHoughCirclesUntyped(CvArr image, void circle_storage, int method, double dp, \n"
" double min_dist, double param1=100, double param2=100, \n"
" int min_radius=0, int max_radius=0) -> CvSeq\n"
""},
{ (char *)"cvFitLine", _wrap_cvFitLine, METH_VARARGS, (char *)"\n"
"cvFitLine(CvArr points, int dist_type, double param, double reps, \n"
" double aeps, float line)\n"
""},
{ (char *)"cvCreateFeatureTree", _wrap_cvCreateFeatureTree, METH_VARARGS, (char *)"cvCreateFeatureTree(CvMat desc) -> CvFeatureTree"},
{ (char *)"cvReleaseFeatureTree", _wrap_cvReleaseFeatureTree, METH_VARARGS, (char *)"cvReleaseFeatureTree(CvFeatureTree tr)"},
{ (char *)"cvFindFeatures", _wrap_cvFindFeatures, METH_VARARGS, (char *)"\n"
"cvFindFeatures(CvFeatureTree tr, CvMat desc, CvMat results, CvMat dist, \n"
" int k=2, int emax=20)\n"
""},
{ (char *)"cvFindFeaturesBoxed", _wrap_cvFindFeaturesBoxed, METH_VARARGS, (char *)"\n"
"cvFindFeaturesBoxed(CvFeatureTree tr, CvMat bounds_min, CvMat bounds_max, \n"
" CvMat results) -> int\n"
""},
{ (char *)"CvSURFPoint_pt_set", _wrap_CvSURFPoint_pt_set, METH_VARARGS, (char *)"CvSURFPoint_pt_set(CvSURFPoint self, CvPoint2D32f pt)"},
{ (char *)"CvSURFPoint_pt_get", _wrap_CvSURFPoint_pt_get, METH_VARARGS, (char *)"CvSURFPoint_pt_get(CvSURFPoint self) -> CvPoint2D32f"},
{ (char *)"CvSURFPoint_laplacian_set", _wrap_CvSURFPoint_laplacian_set, METH_VARARGS, (char *)"CvSURFPoint_laplacian_set(CvSURFPoint self, int laplacian)"},
{ (char *)"CvSURFPoint_laplacian_get", _wrap_CvSURFPoint_laplacian_get, METH_VARARGS, (char *)"CvSURFPoint_laplacian_get(CvSURFPoint self) -> int"},
{ (char *)"CvSURFPoint_size_set", _wrap_CvSURFPoint_size_set, METH_VARARGS, (char *)"CvSURFPoint_size_set(CvSURFPoint self, int size)"},
{ (char *)"CvSURFPoint_size_get", _wrap_CvSURFPoint_size_get, METH_VARARGS, (char *)"CvSURFPoint_size_get(CvSURFPoint self) -> int"},
{ (char *)"CvSURFPoint_dir_set", _wrap_CvSURFPoint_dir_set, METH_VARARGS, (char *)"CvSURFPoint_dir_set(CvSURFPoint self, float dir)"},
{ (char *)"CvSURFPoint_dir_get", _wrap_CvSURFPoint_dir_get, METH_VARARGS, (char *)"CvSURFPoint_dir_get(CvSURFPoint self) -> float"},
{ (char *)"CvSURFPoint_hessian_set", _wrap_CvSURFPoint_hessian_set, METH_VARARGS, (char *)"CvSURFPoint_hessian_set(CvSURFPoint self, float hessian)"},
{ (char *)"CvSURFPoint_hessian_get", _wrap_CvSURFPoint_hessian_get, METH_VARARGS, (char *)"CvSURFPoint_hessian_get(CvSURFPoint self) -> float"},
{ (char *)"new_CvSURFPoint", _wrap_new_CvSURFPoint, METH_VARARGS, (char *)"new_CvSURFPoint() -> CvSURFPoint"},
{ (char *)"delete_CvSURFPoint", _wrap_delete_CvSURFPoint, METH_VARARGS, (char *)"delete_CvSURFPoint(CvSURFPoint self)"},
{ (char *)"CvSURFPoint_swigregister", CvSURFPoint_swigregister, METH_VARARGS, NULL},
{ (char *)"cvSURFPoint", _wrap_cvSURFPoint, METH_VARARGS, (char *)"\n"
"cvSURFPoint(CvPoint2D32f pt, int laplacian, int size, float dir=0, \n"
" float hessian=0) -> CvSURFPoint\n"
""},
{ (char *)"CvSURFParams_extended_set", _wrap_CvSURFParams_extended_set, METH_VARARGS, (char *)"CvSURFParams_extended_set(CvSURFParams self, int extended)"},
{ (char *)"CvSURFParams_extended_get", _wrap_CvSURFParams_extended_get, METH_VARARGS, (char *)"CvSURFParams_extended_get(CvSURFParams self) -> int"},
{ (char *)"CvSURFParams_hessianThreshold_set", _wrap_CvSURFParams_hessianThreshold_set, METH_VARARGS, (char *)"CvSURFParams_hessianThreshold_set(CvSURFParams self, double hessianThreshold)"},
{ (char *)"CvSURFParams_hessianThreshold_get", _wrap_CvSURFParams_hessianThreshold_get, METH_VARARGS, (char *)"CvSURFParams_hessianThreshold_get(CvSURFParams self) -> double"},
{ (char *)"CvSURFParams_nOctaves_set", _wrap_CvSURFParams_nOctaves_set, METH_VARARGS, (char *)"CvSURFParams_nOctaves_set(CvSURFParams self, int nOctaves)"},
{ (char *)"CvSURFParams_nOctaves_get", _wrap_CvSURFParams_nOctaves_get, METH_VARARGS, (char *)"CvSURFParams_nOctaves_get(CvSURFParams self) -> int"},
{ (char *)"CvSURFParams_nOctaveLayers_set", _wrap_CvSURFParams_nOctaveLayers_set, METH_VARARGS, (char *)"CvSURFParams_nOctaveLayers_set(CvSURFParams self, int nOctaveLayers)"},
{ (char *)"CvSURFParams_nOctaveLayers_get", _wrap_CvSURFParams_nOctaveLayers_get, METH_VARARGS, (char *)"CvSURFParams_nOctaveLayers_get(CvSURFParams self) -> int"},
{ (char *)"new_CvSURFParams", _wrap_new_CvSURFParams, METH_VARARGS, (char *)"new_CvSURFParams() -> CvSURFParams"},
{ (char *)"delete_CvSURFParams", _wrap_delete_CvSURFParams, METH_VARARGS, (char *)"delete_CvSURFParams(CvSURFParams self)"},
{ (char *)"CvSURFParams_swigregister", CvSURFParams_swigregister, METH_VARARGS, NULL},
{ (char *)"cvSURFParams", _wrap_cvSURFParams, METH_VARARGS, (char *)"cvSURFParams(double hessianThreshold, int extended=0) -> CvSURFParams"},
{ (char *)"cvExtractSURF", _wrap_cvExtractSURF, METH_VARARGS, (char *)"\n"
"cvExtractSURF(CvArr img, CvArr mask, CvSeq keypoints, CvSeq descriptors, \n"
" CvMemStorage storage, CvSURFParams params)\n"
""},
{ (char *)"cvLoadHaarClassifierCascade", _wrap_cvLoadHaarClassifierCascade, METH_VARARGS, (char *)"cvLoadHaarClassifierCascade(char directory, CvSize orig_window_size) -> CvHaarClassifierCascade"},
{ (char *)"cvSetImagesForHaarClassifierCascade", _wrap_cvSetImagesForHaarClassifierCascade, METH_VARARGS, (char *)"\n"
"cvSetImagesForHaarClassifierCascade(CvHaarClassifierCascade cascade, CvArr sum, CvArr sqsum, \n"
" CvArr tilted_sum, double scale)\n"
""},
{ (char *)"cvRunHaarClassifierCascade", _wrap_cvRunHaarClassifierCascade, METH_VARARGS, (char *)"cvRunHaarClassifierCascade(CvHaarClassifierCascade cascade, CvPoint pt, int start_stage=0) -> int"},
{ (char *)"cvUndistort2", _wrap_cvUndistort2, METH_VARARGS, (char *)"cvUndistort2(CvArr src, CvArr dst, CvMat camera_matrix, CvMat distortion_coeffs)"},
{ (char *)"cvInitUndistortMap", _wrap_cvInitUndistortMap, METH_VARARGS, (char *)"\n"
"cvInitUndistortMap(CvMat camera_matrix, CvMat distortion_coeffs, CvArr mapx, \n"
" CvArr mapy)\n"
""},
{ (char *)"cvInitUndistortRectifyMap", _wrap_cvInitUndistortRectifyMap, METH_VARARGS, (char *)"\n"
"cvInitUndistortRectifyMap(CvMat camera_matrix, CvMat dist_coeffs, CvMat R, CvMat new_camera_matrix, \n"
" CvArr mapx, CvArr mapy)\n"
""},
{ (char *)"cvUndistortPoints", _wrap_cvUndistortPoints, METH_VARARGS, (char *)"\n"
"cvUndistortPoints(CvMat src, CvMat dst, CvMat camera_matrix, CvMat dist_coeffs, \n"
" CvMat R=0, CvMat P=0)\n"
""},
{ (char *)"cvRodrigues2", _wrap_cvRodrigues2, METH_VARARGS, (char *)"cvRodrigues2(CvMat src, CvMat dst, CvMat jacobian=0) -> int"},
{ (char *)"cvFindHomography", _wrap_cvFindHomography, METH_VARARGS, (char *)"\n"
"cvFindHomography(CvMat src_points, CvMat dst_points, CvMat homography, \n"
" int method=0, double ransacReprojThreshold=0, \n"
" CvMat mask=0) -> int\n"
""},
{ (char *)"cvRQDecomp3x3", _wrap_cvRQDecomp3x3, METH_VARARGS, (char *)"\n"
"cvRQDecomp3x3(CvMat matrixM, CvMat matrixR, CvMat matrixQ, CvMat matrixQx=None, \n"
" CvMat matrixQy=None, CvMat matrixQz=None, \n"
" CvPoint3D64f eulerAngles=None)\n"
""},
{ (char *)"cvDecomposeProjectionMatrix", _wrap_cvDecomposeProjectionMatrix, METH_VARARGS, (char *)"\n"
"cvDecomposeProjectionMatrix(CvMat projMatr, CvMat calibMatr, CvMat rotMatr, CvMat posVect, \n"
" CvMat rotMatrX=None, CvMat rotMatrY=None, \n"
" CvMat rotMatrZ=None, CvPoint3D64f eulerAngles=None)\n"
""},
{ (char *)"cvCalcMatMulDeriv", _wrap_cvCalcMatMulDeriv, METH_VARARGS, (char *)"cvCalcMatMulDeriv(CvMat A, CvMat B, CvMat dABdA, CvMat dABdB)"},
{ (char *)"cvComposeRT", _wrap_cvComposeRT, METH_VARARGS, (char *)"\n"
"cvComposeRT(CvMat _rvec1, CvMat _tvec1, CvMat _rvec2, CvMat _tvec2, \n"
" CvMat _rvec3, CvMat _tvec3, CvMat dr3dr1=0, \n"
" CvMat dr3dt1=0, CvMat dr3dr2=0, CvMat dr3dt2=0, \n"
" CvMat dt3dr1=0, CvMat dt3dt1=0, CvMat dt3dr2=0, \n"
" CvMat dt3dt2=0)\n"
""},
{ (char *)"cvProjectPoints2", _wrap_cvProjectPoints2, METH_VARARGS, (char *)"\n"
"cvProjectPoints2(CvMat object_points, CvMat rotation_vector, CvMat translation_vector, \n"
" CvMat camera_matrix, CvMat distortion_coeffs, \n"
" CvMat image_points, CvMat dpdrot=None, \n"
" CvMat dpdt=None, CvMat dpdf=None, \n"
" CvMat dpdc=None, CvMat dpddist=None, double aspect_ratio=0)\n"
""},
{ (char *)"cvFindExtrinsicCameraParams2", _wrap_cvFindExtrinsicCameraParams2, METH_VARARGS, (char *)"\n"
"cvFindExtrinsicCameraParams2(CvMat object_points, CvMat image_points, CvMat camera_matrix, \n"
" CvMat distortion_coeffs, CvMat rotation_vector, \n"
" CvMat translation_vector)\n"
""},
{ (char *)"cvInitIntrinsicParams2D", _wrap_cvInitIntrinsicParams2D, METH_VARARGS, (char *)"\n"
"cvInitIntrinsicParams2D(CvMat object_points, CvMat image_points, CvMat npoints, \n"
" CvSize image_size, CvMat camera_matrix, \n"
" double aspect_ratio=1.)\n"
""},
{ (char *)"cvFindChessboardCorners", _wrap_cvFindChessboardCorners, METH_VARARGS, (char *)"cvFindChessboardCorners(void image, CvSize pattern_size, int flags=1+2) -> int"},
{ (char *)"cvDrawChessboardCorners", _wrap_cvDrawChessboardCorners, METH_VARARGS, (char *)"\n"
"cvDrawChessboardCorners(CvArr image, CvSize pattern_size, CvPoint2D32f corners, \n"
" int pattern_was_found)\n"
""},
{ (char *)"cvCalibrateCamera2", _wrap_cvCalibrateCamera2, METH_VARARGS, (char *)"\n"
"cvCalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, \n"
" CvSize image_size, CvMat camera_matrix, \n"
" CvMat distortion_coeffs, CvMat rotation_vectors=None, \n"
" CvMat translation_vectors=None, \n"
" int flags=0)\n"
""},
{ (char *)"cvCalibrationMatrixValues", _wrap_cvCalibrationMatrixValues, METH_VARARGS, (char *)"\n"
"cvCalibrationMatrixValues(CvMat camera_matrix, CvSize image_size, double aperture_width=0, \n"
" double aperture_height=0, double fovx=None, \n"
" double fovy=None, double focal_length=None, \n"
" CvPoint2D64f principal_point=None, \n"
" double pixel_aspect_ratio=None)\n"
""},
{ (char *)"cvStereoCalibrate", _wrap_cvStereoCalibrate, METH_VARARGS, (char *)"\n"
"cvStereoCalibrate(CvMat object_points, CvMat image_points1, CvMat image_points2, \n"
" CvMat npoints, CvMat camera_matrix1, \n"
" CvMat dist_coeffs1, CvMat camera_matrix2, \n"
" CvMat dist_coeffs2, CvSize image_size, CvMat R, \n"
" CvMat T, CvMat E=0, CvMat F=0, CvTermCriteria term_crit=cvTermCriteria( 1 +2,30,1e-6), \n"
" int flags=256)\n"
""},
{ (char *)"cvStereoRectify", _wrap_cvStereoRectify, METH_VARARGS, (char *)"\n"
"cvStereoRectify(CvMat camera_matrix1, CvMat camera_matrix2, CvMat dist_coeffs1, \n"
" CvMat dist_coeffs2, CvSize image_size, \n"
" CvMat R, CvMat T, CvMat R1, CvMat R2, \n"
" CvMat P1, CvMat P2, CvMat Q=0, int flags=1024)\n"
""},
{ (char *)"cvStereoRectifyUncalibrated", _wrap_cvStereoRectifyUncalibrated, METH_VARARGS, (char *)"\n"
"cvStereoRectifyUncalibrated(CvMat points1, CvMat points2, CvMat F, CvSize img_size, \n"
" CvMat H1, CvMat H2, double threshold=5) -> int\n"
""},
{ (char *)"cvCreatePOSITObject", _wrap_cvCreatePOSITObject, METH_VARARGS, (char *)"cvCreatePOSITObject(CvPoint3D32f points, int point_count) -> CvPOSITObject"},
{ (char *)"cvPOSIT", _wrap_cvPOSIT, METH_VARARGS, (char *)"\n"
"cvPOSIT(CvPOSITObject posit_object, CvPoint2D32f image_points, \n"
" double focal_length, CvTermCriteria criteria, \n"
" CvMatr32f rotation_matrix, CvVect32f translation_vector)\n"
""},
{ (char *)"cvRANSACUpdateNumIters", _wrap_cvRANSACUpdateNumIters, METH_VARARGS, (char *)"cvRANSACUpdateNumIters(double p, double err_prob, int model_points, int max_iters) -> int"},
{ (char *)"cvConvertPointsHomogeneous", _wrap_cvConvertPointsHomogeneous, METH_VARARGS, (char *)"cvConvertPointsHomogeneous(CvMat src, CvMat dst)"},
{ (char *)"cvFindFundamentalMat", _wrap_cvFindFundamentalMat, METH_VARARGS, (char *)"\n"
"cvFindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix, \n"
" int method=8, double param1=3., double param2=0.99, \n"
" CvMat status=None) -> int\n"
""},
{ (char *)"cvComputeCorrespondEpilines", _wrap_cvComputeCorrespondEpilines, METH_VARARGS, (char *)"\n"
"cvComputeCorrespondEpilines(CvMat points, int which_image, CvMat fundamental_matrix, \n"
" CvMat correspondent_lines)\n"
""},
{ (char *)"CvStereoBMState_preFilterType_set", _wrap_CvStereoBMState_preFilterType_set, METH_VARARGS, (char *)"CvStereoBMState_preFilterType_set(CvStereoBMState self, int preFilterType)"},
{ (char *)"CvStereoBMState_preFilterType_get", _wrap_CvStereoBMState_preFilterType_get, METH_VARARGS, (char *)"CvStereoBMState_preFilterType_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_preFilterSize_set", _wrap_CvStereoBMState_preFilterSize_set, METH_VARARGS, (char *)"CvStereoBMState_preFilterSize_set(CvStereoBMState self, int preFilterSize)"},
{ (char *)"CvStereoBMState_preFilterSize_get", _wrap_CvStereoBMState_preFilterSize_get, METH_VARARGS, (char *)"CvStereoBMState_preFilterSize_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_preFilterCap_set", _wrap_CvStereoBMState_preFilterCap_set, METH_VARARGS, (char *)"CvStereoBMState_preFilterCap_set(CvStereoBMState self, int preFilterCap)"},
{ (char *)"CvStereoBMState_preFilterCap_get", _wrap_CvStereoBMState_preFilterCap_get, METH_VARARGS, (char *)"CvStereoBMState_preFilterCap_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_SADWindowSize_set", _wrap_CvStereoBMState_SADWindowSize_set, METH_VARARGS, (char *)"CvStereoBMState_SADWindowSize_set(CvStereoBMState self, int SADWindowSize)"},
{ (char *)"CvStereoBMState_SADWindowSize_get", _wrap_CvStereoBMState_SADWindowSize_get, METH_VARARGS, (char *)"CvStereoBMState_SADWindowSize_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_minDisparity_set", _wrap_CvStereoBMState_minDisparity_set, METH_VARARGS, (char *)"CvStereoBMState_minDisparity_set(CvStereoBMState self, int minDisparity)"},
{ (char *)"CvStereoBMState_minDisparity_get", _wrap_CvStereoBMState_minDisparity_get, METH_VARARGS, (char *)"CvStereoBMState_minDisparity_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_numberOfDisparities_set", _wrap_CvStereoBMState_numberOfDisparities_set, METH_VARARGS, (char *)"CvStereoBMState_numberOfDisparities_set(CvStereoBMState self, int numberOfDisparities)"},
{ (char *)"CvStereoBMState_numberOfDisparities_get", _wrap_CvStereoBMState_numberOfDisparities_get, METH_VARARGS, (char *)"CvStereoBMState_numberOfDisparities_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_textureThreshold_set", _wrap_CvStereoBMState_textureThreshold_set, METH_VARARGS, (char *)"CvStereoBMState_textureThreshold_set(CvStereoBMState self, int textureThreshold)"},
{ (char *)"CvStereoBMState_textureThreshold_get", _wrap_CvStereoBMState_textureThreshold_get, METH_VARARGS, (char *)"CvStereoBMState_textureThreshold_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_uniquenessRatio_set", _wrap_CvStereoBMState_uniquenessRatio_set, METH_VARARGS, (char *)"CvStereoBMState_uniquenessRatio_set(CvStereoBMState self, int uniquenessRatio)"},
{ (char *)"CvStereoBMState_uniquenessRatio_get", _wrap_CvStereoBMState_uniquenessRatio_get, METH_VARARGS, (char *)"CvStereoBMState_uniquenessRatio_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_speckleWindowSize_set", _wrap_CvStereoBMState_speckleWindowSize_set, METH_VARARGS, (char *)"CvStereoBMState_speckleWindowSize_set(CvStereoBMState self, int speckleWindowSize)"},
{ (char *)"CvStereoBMState_speckleWindowSize_get", _wrap_CvStereoBMState_speckleWindowSize_get, METH_VARARGS, (char *)"CvStereoBMState_speckleWindowSize_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_speckleRange_set", _wrap_CvStereoBMState_speckleRange_set, METH_VARARGS, (char *)"CvStereoBMState_speckleRange_set(CvStereoBMState self, int speckleRange)"},
{ (char *)"CvStereoBMState_speckleRange_get", _wrap_CvStereoBMState_speckleRange_get, METH_VARARGS, (char *)"CvStereoBMState_speckleRange_get(CvStereoBMState self) -> int"},
{ (char *)"CvStereoBMState_preFilteredImg0_set", _wrap_CvStereoBMState_preFilteredImg0_set, METH_VARARGS, (char *)"CvStereoBMState_preFilteredImg0_set(CvStereoBMState self, CvMat preFilteredImg0)"},
{ (char *)"CvStereoBMState_preFilteredImg0_get", _wrap_CvStereoBMState_preFilteredImg0_get, METH_VARARGS, (char *)"CvStereoBMState_preFilteredImg0_get(CvStereoBMState self) -> CvMat"},
{ (char *)"CvStereoBMState_preFilteredImg1_set", _wrap_CvStereoBMState_preFilteredImg1_set, METH_VARARGS, (char *)"CvStereoBMState_preFilteredImg1_set(CvStereoBMState self, CvMat preFilteredImg1)"},
{ (char *)"CvStereoBMState_preFilteredImg1_get", _wrap_CvStereoBMState_preFilteredImg1_get, METH_VARARGS, (char *)"CvStereoBMState_preFilteredImg1_get(CvStereoBMState self) -> CvMat"},
{ (char *)"CvStereoBMState_slidingSumBuf_set", _wrap_CvStereoBMState_slidingSumBuf_set, METH_VARARGS, (char *)"CvStereoBMState_slidingSumBuf_set(CvStereoBMState self, CvMat slidingSumBuf)"},
{ (char *)"CvStereoBMState_slidingSumBuf_get", _wrap_CvStereoBMState_slidingSumBuf_get, METH_VARARGS, (char *)"CvStereoBMState_slidingSumBuf_get(CvStereoBMState self) -> CvMat"},
{ (char *)"new_CvStereoBMState", _wrap_new_CvStereoBMState, METH_VARARGS, (char *)"new_CvStereoBMState() -> CvStereoBMState"},
{ (char *)"delete_CvStereoBMState", _wrap_delete_CvStereoBMState, METH_VARARGS, (char *)"delete_CvStereoBMState(CvStereoBMState self)"},
{ (char *)"CvStereoBMState_swigregister", CvStereoBMState_swigregister, METH_VARARGS, NULL},
{ (char *)"cvCreateStereoBMState", _wrap_cvCreateStereoBMState, METH_VARARGS, (char *)"cvCreateStereoBMState(int preset=0, int numberOfDisparities=0) -> CvStereoBMState"},
{ (char *)"cvReleaseStereoBMState", _wrap_cvReleaseStereoBMState, METH_VARARGS, (char *)"cvReleaseStereoBMState(CvStereoBMState state)"},
{ (char *)"cvFindStereoCorrespondenceBM", _wrap_cvFindStereoCorrespondenceBM, METH_VARARGS, (char *)"cvFindStereoCorrespondenceBM(CvArr left, CvArr right, CvArr disparity, CvStereoBMState state)"},
{ (char *)"CvStereoGCState_Ithreshold_set", _wrap_CvStereoGCState_Ithreshold_set, METH_VARARGS, (char *)"CvStereoGCState_Ithreshold_set(CvStereoGCState self, int Ithreshold)"},
{ (char *)"CvStereoGCState_Ithreshold_get", _wrap_CvStereoGCState_Ithreshold_get, METH_VARARGS, (char *)"CvStereoGCState_Ithreshold_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_interactionRadius_set", _wrap_CvStereoGCState_interactionRadius_set, METH_VARARGS, (char *)"CvStereoGCState_interactionRadius_set(CvStereoGCState self, int interactionRadius)"},
{ (char *)"CvStereoGCState_interactionRadius_get", _wrap_CvStereoGCState_interactionRadius_get, METH_VARARGS, (char *)"CvStereoGCState_interactionRadius_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_K_set", _wrap_CvStereoGCState_K_set, METH_VARARGS, (char *)"CvStereoGCState_K_set(CvStereoGCState self, float K)"},
{ (char *)"CvStereoGCState_K_get", _wrap_CvStereoGCState_K_get, METH_VARARGS, (char *)"CvStereoGCState_K_get(CvStereoGCState self) -> float"},
{ (char *)"CvStereoGCState__lambda_set", _wrap_CvStereoGCState__lambda_set, METH_VARARGS, (char *)"CvStereoGCState__lambda_set(CvStereoGCState self, float lambda)"},
{ (char *)"CvStereoGCState__lambda_get", _wrap_CvStereoGCState__lambda_get, METH_VARARGS, (char *)"CvStereoGCState__lambda_get(CvStereoGCState self) -> float"},
{ (char *)"CvStereoGCState_lambda1_set", _wrap_CvStereoGCState_lambda1_set, METH_VARARGS, (char *)"CvStereoGCState_lambda1_set(CvStereoGCState self, float lambda1)"},
{ (char *)"CvStereoGCState_lambda1_get", _wrap_CvStereoGCState_lambda1_get, METH_VARARGS, (char *)"CvStereoGCState_lambda1_get(CvStereoGCState self) -> float"},
{ (char *)"CvStereoGCState_lambda2_set", _wrap_CvStereoGCState_lambda2_set, METH_VARARGS, (char *)"CvStereoGCState_lambda2_set(CvStereoGCState self, float lambda2)"},
{ (char *)"CvStereoGCState_lambda2_get", _wrap_CvStereoGCState_lambda2_get, METH_VARARGS, (char *)"CvStereoGCState_lambda2_get(CvStereoGCState self) -> float"},
{ (char *)"CvStereoGCState_occlusionCost_set", _wrap_CvStereoGCState_occlusionCost_set, METH_VARARGS, (char *)"CvStereoGCState_occlusionCost_set(CvStereoGCState self, int occlusionCost)"},
{ (char *)"CvStereoGCState_occlusionCost_get", _wrap_CvStereoGCState_occlusionCost_get, METH_VARARGS, (char *)"CvStereoGCState_occlusionCost_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_minDisparity_set", _wrap_CvStereoGCState_minDisparity_set, METH_VARARGS, (char *)"CvStereoGCState_minDisparity_set(CvStereoGCState self, int minDisparity)"},
{ (char *)"CvStereoGCState_minDisparity_get", _wrap_CvStereoGCState_minDisparity_get, METH_VARARGS, (char *)"CvStereoGCState_minDisparity_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_numberOfDisparities_set", _wrap_CvStereoGCState_numberOfDisparities_set, METH_VARARGS, (char *)"CvStereoGCState_numberOfDisparities_set(CvStereoGCState self, int numberOfDisparities)"},
{ (char *)"CvStereoGCState_numberOfDisparities_get", _wrap_CvStereoGCState_numberOfDisparities_get, METH_VARARGS, (char *)"CvStereoGCState_numberOfDisparities_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_maxIters_set", _wrap_CvStereoGCState_maxIters_set, METH_VARARGS, (char *)"CvStereoGCState_maxIters_set(CvStereoGCState self, int maxIters)"},
{ (char *)"CvStereoGCState_maxIters_get", _wrap_CvStereoGCState_maxIters_get, METH_VARARGS, (char *)"CvStereoGCState_maxIters_get(CvStereoGCState self) -> int"},
{ (char *)"CvStereoGCState_left_set", _wrap_CvStereoGCState_left_set, METH_VARARGS, (char *)"CvStereoGCState_left_set(CvStereoGCState self, CvMat left)"},
{ (char *)"CvStereoGCState_left_get", _wrap_CvStereoGCState_left_get, METH_VARARGS, (char *)"CvStereoGCState_left_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_right_set", _wrap_CvStereoGCState_right_set, METH_VARARGS, (char *)"CvStereoGCState_right_set(CvStereoGCState self, CvMat right)"},
{ (char *)"CvStereoGCState_right_get", _wrap_CvStereoGCState_right_get, METH_VARARGS, (char *)"CvStereoGCState_right_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_dispLeft_set", _wrap_CvStereoGCState_dispLeft_set, METH_VARARGS, (char *)"CvStereoGCState_dispLeft_set(CvStereoGCState self, CvMat dispLeft)"},
{ (char *)"CvStereoGCState_dispLeft_get", _wrap_CvStereoGCState_dispLeft_get, METH_VARARGS, (char *)"CvStereoGCState_dispLeft_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_dispRight_set", _wrap_CvStereoGCState_dispRight_set, METH_VARARGS, (char *)"CvStereoGCState_dispRight_set(CvStereoGCState self, CvMat dispRight)"},
{ (char *)"CvStereoGCState_dispRight_get", _wrap_CvStereoGCState_dispRight_get, METH_VARARGS, (char *)"CvStereoGCState_dispRight_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_ptrLeft_set", _wrap_CvStereoGCState_ptrLeft_set, METH_VARARGS, (char *)"CvStereoGCState_ptrLeft_set(CvStereoGCState self, CvMat ptrLeft)"},
{ (char *)"CvStereoGCState_ptrLeft_get", _wrap_CvStereoGCState_ptrLeft_get, METH_VARARGS, (char *)"CvStereoGCState_ptrLeft_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_ptrRight_set", _wrap_CvStereoGCState_ptrRight_set, METH_VARARGS, (char *)"CvStereoGCState_ptrRight_set(CvStereoGCState self, CvMat ptrRight)"},
{ (char *)"CvStereoGCState_ptrRight_get", _wrap_CvStereoGCState_ptrRight_get, METH_VARARGS, (char *)"CvStereoGCState_ptrRight_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_vtxBuf_set", _wrap_CvStereoGCState_vtxBuf_set, METH_VARARGS, (char *)"CvStereoGCState_vtxBuf_set(CvStereoGCState self, CvMat vtxBuf)"},
{ (char *)"CvStereoGCState_vtxBuf_get", _wrap_CvStereoGCState_vtxBuf_get, METH_VARARGS, (char *)"CvStereoGCState_vtxBuf_get(CvStereoGCState self) -> CvMat"},
{ (char *)"CvStereoGCState_edgeBuf_set", _wrap_CvStereoGCState_edgeBuf_set, METH_VARARGS, (char *)"CvStereoGCState_edgeBuf_set(CvStereoGCState self, CvMat edgeBuf)"},
{ (char *)"CvStereoGCState_edgeBuf_get", _wrap_CvStereoGCState_edgeBuf_get, METH_VARARGS, (char *)"CvStereoGCState_edgeBuf_get(CvStereoGCState self) -> CvMat"},
{ (char *)"new_CvStereoGCState", _wrap_new_CvStereoGCState, METH_VARARGS, (char *)"new_CvStereoGCState() -> CvStereoGCState"},
{ (char *)"delete_CvStereoGCState", _wrap_delete_CvStereoGCState, METH_VARARGS, (char *)"delete_CvStereoGCState(CvStereoGCState self)"},
{ (char *)"CvStereoGCState_swigregister", CvStereoGCState_swigregister, METH_VARARGS, NULL},
{ (char *)"cvCreateStereoGCState", _wrap_cvCreateStereoGCState, METH_VARARGS, (char *)"cvCreateStereoGCState(int numberOfDisparities, int maxIters) -> CvStereoGCState"},
{ (char *)"cvReleaseStereoGCState", _wrap_cvReleaseStereoGCState, METH_VARARGS, (char *)"cvReleaseStereoGCState(CvStereoGCState state)"},
{ (char *)"cvFindStereoCorrespondenceGC", _wrap_cvFindStereoCorrespondenceGC, METH_VARARGS, (char *)"\n"
"cvFindStereoCorrespondenceGC(CvArr left, CvArr right, CvArr disparityLeft, CvArr disparityRight, \n"
" CvStereoGCState state, int useDisparityGuess=0)\n"
""},
{ (char *)"cvReprojectImageTo3D", _wrap_cvReprojectImageTo3D, METH_VARARGS, (char *)"cvReprojectImageTo3D(CvArr disparityImage, CvArr _3dImage, CvMat Q)"},
{ (char *)"new_CvBaseImageFilter", _wrap_new_CvBaseImageFilter, METH_VARARGS, (char *)"\n"
"CvBaseImageFilter()\n"
"CvBaseImageFilter(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"CvBaseImageFilter(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"CvBaseImageFilter(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"new_CvBaseImageFilter(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize) -> CvBaseImageFilter\n"
""},
{ (char *)"delete_CvBaseImageFilter", _wrap_delete_CvBaseImageFilter, METH_VARARGS, (char *)"delete_CvBaseImageFilter(CvBaseImageFilter self)"},
{ (char *)"CvBaseImageFilter_init", _wrap_CvBaseImageFilter_init, METH_VARARGS, (char *)"\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvBaseImageFilter_init(CvBaseImageFilter self, int _max_width, int _src_type, \n"
" int _dst_type, bool _is_separable, CvSize _ksize)\n"
""},
{ (char *)"CvBaseImageFilter_clear", _wrap_CvBaseImageFilter_clear, METH_VARARGS, (char *)"CvBaseImageFilter_clear(CvBaseImageFilter self)"},
{ (char *)"CvBaseImageFilter_process", _wrap_CvBaseImageFilter_process, METH_VARARGS, (char *)"\n"
"process(CvMat _src, CvMat _dst, CvRect _src_roi=cvRect(0,0,-1,-1), \n"
" CvPoint _dst_origin=cvPoint(0,0), int _flags=0) -> int\n"
"process(CvMat _src, CvMat _dst, CvRect _src_roi=cvRect(0,0,-1,-1), \n"
" CvPoint _dst_origin=cvPoint(0,0)) -> int\n"
"process(CvMat _src, CvMat _dst, CvRect _src_roi=cvRect(0,0,-1,-1)) -> int\n"
"CvBaseImageFilter_process(CvBaseImageFilter self, CvMat _src, CvMat _dst) -> int\n"
""},
{ (char *)"CvBaseImageFilter_get_src_type", _wrap_CvBaseImageFilter_get_src_type, METH_VARARGS, (char *)"CvBaseImageFilter_get_src_type(CvBaseImageFilter self) -> int"},
{ (char *)"CvBaseImageFilter_get_dst_type", _wrap_CvBaseImageFilter_get_dst_type, METH_VARARGS, (char *)"CvBaseImageFilter_get_dst_type(CvBaseImageFilter self) -> int"},
{ (char *)"CvBaseImageFilter_get_work_type", _wrap_CvBaseImageFilter_get_work_type, METH_VARARGS, (char *)"CvBaseImageFilter_get_work_type(CvBaseImageFilter self) -> int"},
{ (char *)"CvBaseImageFilter_get_kernel_size", _wrap_CvBaseImageFilter_get_kernel_size, METH_VARARGS, (char *)"CvBaseImageFilter_get_kernel_size(CvBaseImageFilter self) -> CvSize"},
{ (char *)"CvBaseImageFilter_get_anchor", _wrap_CvBaseImageFilter_get_anchor, METH_VARARGS, (char *)"CvBaseImageFilter_get_anchor(CvBaseImageFilter self) -> CvPoint"},
{ (char *)"CvBaseImageFilter_get_width", _wrap_CvBaseImageFilter_get_width, METH_VARARGS, (char *)"CvBaseImageFilter_get_width(CvBaseImageFilter self) -> int"},
{ (char *)"CvBaseImageFilter_get_x_filter_func", _wrap_CvBaseImageFilter_get_x_filter_func, METH_VARARGS, (char *)"CvBaseImageFilter_get_x_filter_func(CvBaseImageFilter self) -> CvRowFilterFunc"},
{ (char *)"CvBaseImageFilter_get_y_filter_func", _wrap_CvBaseImageFilter_get_y_filter_func, METH_VARARGS, (char *)"CvBaseImageFilter_get_y_filter_func(CvBaseImageFilter self) -> CvColumnFilterFunc"},
{ (char *)"CvBaseImageFilter_swigregister", CvBaseImageFilter_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvSepFilter", _wrap_new_CvSepFilter, METH_VARARGS, (char *)"\n"
"CvSepFilter()\n"
"CvSepFilter(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"CvSepFilter(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"CvSepFilter(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1))\n"
"new_CvSepFilter(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky) -> CvSepFilter\n"
""},
{ (char *)"delete_CvSepFilter", _wrap_delete_CvSepFilter, METH_VARARGS, (char *)"delete_CvSepFilter(CvSepFilter self)"},
{ (char *)"CvSepFilter_init_deriv", _wrap_CvSepFilter_init_deriv, METH_VARARGS, (char *)"\n"
"init_deriv(int _max_width, int _src_type, int _dst_type, int dx, \n"
" int dy, int aperture_size, int flags=0)\n"
"CvSepFilter_init_deriv(CvSepFilter self, int _max_width, int _src_type, int _dst_type, \n"
" int dx, int dy, int aperture_size)\n"
""},
{ (char *)"CvSepFilter_init_gaussian", _wrap_CvSepFilter_init_gaussian, METH_VARARGS, (char *)"\n"
"CvSepFilter_init_gaussian(CvSepFilter self, int _max_width, int _src_type, int _dst_type, \n"
" int gaussian_size, double sigma)\n"
""},
{ (char *)"CvSepFilter_init", _wrap_CvSepFilter_init, METH_VARARGS, (char *)"\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1))\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvSepFilter_init(CvSepFilter self, int _max_width, int _src_type, int _dst_type, \n"
" bool _is_separable, CvSize _ksize)\n"
""},
{ (char *)"CvSepFilter_clear", _wrap_CvSepFilter_clear, METH_VARARGS, (char *)"CvSepFilter_clear(CvSepFilter self)"},
{ (char *)"CvSepFilter_get_x_kernel", _wrap_CvSepFilter_get_x_kernel, METH_VARARGS, (char *)"CvSepFilter_get_x_kernel(CvSepFilter self) -> CvMat"},
{ (char *)"CvSepFilter_get_y_kernel", _wrap_CvSepFilter_get_y_kernel, METH_VARARGS, (char *)"CvSepFilter_get_y_kernel(CvSepFilter self) -> CvMat"},
{ (char *)"CvSepFilter_get_x_kernel_flags", _wrap_CvSepFilter_get_x_kernel_flags, METH_VARARGS, (char *)"CvSepFilter_get_x_kernel_flags(CvSepFilter self) -> int"},
{ (char *)"CvSepFilter_get_y_kernel_flags", _wrap_CvSepFilter_get_y_kernel_flags, METH_VARARGS, (char *)"CvSepFilter_get_y_kernel_flags(CvSepFilter self) -> int"},
{ (char *)"CvSepFilter_init_gaussian_kernel", _wrap_CvSepFilter_init_gaussian_kernel, METH_VARARGS, (char *)"\n"
"init_gaussian_kernel(CvMat kernel, double sigma=-1)\n"
"CvSepFilter_init_gaussian_kernel(CvMat kernel)\n"
""},
{ (char *)"CvSepFilter_init_sobel_kernel", _wrap_CvSepFilter_init_sobel_kernel, METH_VARARGS, (char *)"\n"
"init_sobel_kernel(CvMat _kx, CvMat _ky, int dx, int dy, int flags=0)\n"
"CvSepFilter_init_sobel_kernel(CvMat _kx, CvMat _ky, int dx, int dy)\n"
""},
{ (char *)"CvSepFilter_init_scharr_kernel", _wrap_CvSepFilter_init_scharr_kernel, METH_VARARGS, (char *)"\n"
"init_scharr_kernel(CvMat _kx, CvMat _ky, int dx, int dy, int flags=0)\n"
"CvSepFilter_init_scharr_kernel(CvMat _kx, CvMat _ky, int dx, int dy)\n"
""},
{ (char *)"CvSepFilter_swigregister", CvSepFilter_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvLinearFilter", _wrap_new_CvLinearFilter, METH_VARARGS, (char *)"\n"
"CvLinearFilter()\n"
"CvLinearFilter(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1), int _border_mode=1, \n"
" CvScalar _border_value=cvScalarAll(0))\n"
"CvLinearFilter(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1), int _border_mode=1)\n"
"CvLinearFilter(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1))\n"
"new_CvLinearFilter(int _max_width, int _src_type, int _dst_type, CvMat _kernel) -> CvLinearFilter\n"
""},
{ (char *)"delete_CvLinearFilter", _wrap_delete_CvLinearFilter, METH_VARARGS, (char *)"delete_CvLinearFilter(CvLinearFilter self)"},
{ (char *)"CvLinearFilter_init", _wrap_CvLinearFilter_init, METH_VARARGS, (char *)"\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1), int _border_mode=1, \n"
" CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1), int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kernel, \n"
" CvPoint _anchor=cvPoint(-1,-1))\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kernel)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvLinearFilter_init(CvLinearFilter self, int _max_width, int _src_type, \n"
" int _dst_type, bool _is_separable, CvSize _ksize)\n"
""},
{ (char *)"CvLinearFilter_clear", _wrap_CvLinearFilter_clear, METH_VARARGS, (char *)"CvLinearFilter_clear(CvLinearFilter self)"},
{ (char *)"CvLinearFilter_get_kernel", _wrap_CvLinearFilter_get_kernel, METH_VARARGS, (char *)"CvLinearFilter_get_kernel(CvLinearFilter self) -> CvMat"},
{ (char *)"CvLinearFilter_get_kernel_sparse_buf", _wrap_CvLinearFilter_get_kernel_sparse_buf, METH_VARARGS, (char *)"CvLinearFilter_get_kernel_sparse_buf(CvLinearFilter self) -> uchar"},
{ (char *)"CvLinearFilter_get_kernel_sparse_count", _wrap_CvLinearFilter_get_kernel_sparse_count, METH_VARARGS, (char *)"CvLinearFilter_get_kernel_sparse_count(CvLinearFilter self) -> int"},
{ (char *)"CvLinearFilter_swigregister", CvLinearFilter_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvBoxFilter", _wrap_new_CvBoxFilter, METH_VARARGS, (char *)"\n"
"CvBoxFilter()\n"
"CvBoxFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"CvBoxFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"CvBoxFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"new_CvBoxFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize) -> CvBoxFilter\n"
""},
{ (char *)"CvBoxFilter_init", _wrap_CvBoxFilter_init, METH_VARARGS, (char *)"\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvBoxFilter_init(CvBoxFilter self, int _max_width, int _src_type, int _dst_type, \n"
" bool _normalized, CvSize _ksize)\n"
""},
{ (char *)"delete_CvBoxFilter", _wrap_delete_CvBoxFilter, METH_VARARGS, (char *)"delete_CvBoxFilter(CvBoxFilter self)"},
{ (char *)"CvBoxFilter_is_normalized", _wrap_CvBoxFilter_is_normalized, METH_VARARGS, (char *)"CvBoxFilter_is_normalized(CvBoxFilter self) -> bool"},
{ (char *)"CvBoxFilter_get_scale", _wrap_CvBoxFilter_get_scale, METH_VARARGS, (char *)"CvBoxFilter_get_scale(CvBoxFilter self) -> double"},
{ (char *)"CvBoxFilter_get_sum_buf", _wrap_CvBoxFilter_get_sum_buf, METH_VARARGS, (char *)"CvBoxFilter_get_sum_buf(CvBoxFilter self) -> uchar"},
{ (char *)"CvBoxFilter_get_sum_count_ptr", _wrap_CvBoxFilter_get_sum_count_ptr, METH_VARARGS, (char *)"CvBoxFilter_get_sum_count_ptr(CvBoxFilter self) -> int"},
{ (char *)"CvBoxFilter_swigregister", CvBoxFilter_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvLaplaceFilter", _wrap_new_CvLaplaceFilter, METH_VARARGS, (char *)"\n"
"CvLaplaceFilter()\n"
"CvLaplaceFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize, int _border_mode=1, \n"
" CvScalar _border_value=cvScalarAll(0))\n"
"CvLaplaceFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize, int _border_mode=1)\n"
"new_CvLaplaceFilter(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize) -> CvLaplaceFilter\n"
""},
{ (char *)"delete_CvLaplaceFilter", _wrap_delete_CvLaplaceFilter, METH_VARARGS, (char *)"delete_CvLaplaceFilter(CvLaplaceFilter self)"},
{ (char *)"CvLaplaceFilter_init", _wrap_CvLaplaceFilter_init, METH_VARARGS, (char *)"\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize, int _border_mode=1, \n"
" CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize, int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _normalized, \n"
" int _ksize)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize)\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, CvMat _kx, \n"
" CvMat _ky, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvLaplaceFilter_init(CvLaplaceFilter self, int _max_width, int _src_type, \n"
" int _dst_type, CvMat _kx, CvMat _ky)\n"
""},
{ (char *)"CvLaplaceFilter_is_normalized", _wrap_CvLaplaceFilter_is_normalized, METH_VARARGS, (char *)"CvLaplaceFilter_is_normalized(CvLaplaceFilter self) -> bool"},
{ (char *)"CvLaplaceFilter_is_basic_laplacian", _wrap_CvLaplaceFilter_is_basic_laplacian, METH_VARARGS, (char *)"CvLaplaceFilter_is_basic_laplacian(CvLaplaceFilter self) -> bool"},
{ (char *)"CvLaplaceFilter_swigregister", CvLaplaceFilter_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvMorphology", _wrap_new_CvMorphology, METH_VARARGS, (char *)"\n"
"CvMorphology()\n"
"CvMorphology(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"CvMorphology(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"CvMorphology(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1))\n"
"CvMorphology(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0))\n"
"new_CvMorphology(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element) -> CvMorphology\n"
""},
{ (char *)"delete_CvMorphology", _wrap_delete_CvMorphology, METH_VARARGS, (char *)"delete_CvMorphology(CvMorphology self)"},
{ (char *)"CvMorphology_init", _wrap_CvMorphology_init, METH_VARARGS, (char *)"\n"
"init(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0), \n"
" CvPoint _anchor=cvPoint(-1,-1))\n"
"init(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element, CvSize _ksize=cvSize(0,0))\n"
"init(int _operation, int _max_width, int _src_dst_type, \n"
" int _element_shape, CvMat _element)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1, CvScalar _border_value=cvScalarAll(0))\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1), \n"
" int _border_mode=1)\n"
"init(int _max_width, int _src_type, int _dst_type, bool _is_separable, \n"
" CvSize _ksize, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvMorphology_init(CvMorphology self, int _max_width, int _src_type, int _dst_type, \n"
" bool _is_separable, CvSize _ksize)\n"
""},
{ (char *)"CvMorphology_clear", _wrap_CvMorphology_clear, METH_VARARGS, (char *)"CvMorphology_clear(CvMorphology self)"},
{ (char *)"CvMorphology_get_element", _wrap_CvMorphology_get_element, METH_VARARGS, (char *)"CvMorphology_get_element(CvMorphology self) -> CvMat"},
{ (char *)"CvMorphology_get_element_shape", _wrap_CvMorphology_get_element_shape, METH_VARARGS, (char *)"CvMorphology_get_element_shape(CvMorphology self) -> int"},
{ (char *)"CvMorphology_get_operation", _wrap_CvMorphology_get_operation, METH_VARARGS, (char *)"CvMorphology_get_operation(CvMorphology self) -> int"},
{ (char *)"CvMorphology_get_element_sparse_buf", _wrap_CvMorphology_get_element_sparse_buf, METH_VARARGS, (char *)"CvMorphology_get_element_sparse_buf(CvMorphology self) -> uchar"},
{ (char *)"CvMorphology_get_element_sparse_count", _wrap_CvMorphology_get_element_sparse_count, METH_VARARGS, (char *)"CvMorphology_get_element_sparse_count(CvMorphology self) -> int"},
{ (char *)"CvMorphology_init_binary_element", _wrap_CvMorphology_init_binary_element, METH_VARARGS, (char *)"\n"
"init_binary_element(CvMat _element, int _element_shape, CvPoint _anchor=cvPoint(-1,-1))\n"
"CvMorphology_init_binary_element(CvMat _element, int _element_shape)\n"
""},
{ (char *)"CvMorphology_swigregister", CvMorphology_swigregister, METH_VARARGS, NULL},
{ (char *)"new_CvLevMarq", _wrap_new_CvLevMarq, METH_VARARGS, (char *)"\n"
"CvLevMarq()\n"
"CvLevMarq(int nparams, int nerrs, CvTermCriteria criteria=cvTermCriteria(2 +1,30,DBL_EPSILON), \n"
" bool completeSymmFlag=False)\n"
"CvLevMarq(int nparams, int nerrs, CvTermCriteria criteria=cvTermCriteria(2 +1,30,DBL_EPSILON))\n"
"new_CvLevMarq(int nparams, int nerrs) -> CvLevMarq\n"
""},
{ (char *)"delete_CvLevMarq", _wrap_delete_CvLevMarq, METH_VARARGS, (char *)"delete_CvLevMarq(CvLevMarq self)"},
{ (char *)"CvLevMarq_init", _wrap_CvLevMarq_init, METH_VARARGS, (char *)"\n"
"init(int nparams, int nerrs, CvTermCriteria criteria=cvTermCriteria(2 +1,30,DBL_EPSILON), \n"
" bool completeSymmFlag=False)\n"
"init(int nparams, int nerrs, CvTermCriteria criteria=cvTermCriteria(2 +1,30,DBL_EPSILON))\n"
"CvLevMarq_init(CvLevMarq self, int nparams, int nerrs)\n"
""},
{ (char *)"CvLevMarq_update", _wrap_CvLevMarq_update, METH_VARARGS, (char *)"CvLevMarq_update(CvLevMarq self, CvMat param, CvMat J, CvMat err) -> bool"},
{ (char *)"CvLevMarq_updateAlt", _wrap_CvLevMarq_updateAlt, METH_VARARGS, (char *)"\n"
"CvLevMarq_updateAlt(CvLevMarq self, CvMat param, CvMat JtJ, CvMat JtErr, \n"
" double errNorm) -> bool\n"
""},
{ (char *)"CvLevMarq_clear", _wrap_CvLevMarq_clear, METH_VARARGS, (char *)"CvLevMarq_clear(CvLevMarq self)"},
{ (char *)"CvLevMarq_step", _wrap_CvLevMarq_step, METH_VARARGS, (char *)"CvLevMarq_step(CvLevMarq self)"},
{ (char *)"CvLevMarq_mask_set", _wrap_CvLevMarq_mask_set, METH_VARARGS, (char *)"CvLevMarq_mask_set(CvLevMarq self, CvMat mask)"},
{ (char *)"CvLevMarq_mask_get", _wrap_CvLevMarq_mask_get, METH_VARARGS, (char *)"CvLevMarq_mask_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_prevParam_set", _wrap_CvLevMarq_prevParam_set, METH_VARARGS, (char *)"CvLevMarq_prevParam_set(CvLevMarq self, CvMat prevParam)"},
{ (char *)"CvLevMarq_prevParam_get", _wrap_CvLevMarq_prevParam_get, METH_VARARGS, (char *)"CvLevMarq_prevParam_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_param_set", _wrap_CvLevMarq_param_set, METH_VARARGS, (char *)"CvLevMarq_param_set(CvLevMarq self, CvMat param)"},
{ (char *)"CvLevMarq_param_get", _wrap_CvLevMarq_param_get, METH_VARARGS, (char *)"CvLevMarq_param_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_J_set", _wrap_CvLevMarq_J_set, METH_VARARGS, (char *)"CvLevMarq_J_set(CvLevMarq self, CvMat J)"},
{ (char *)"CvLevMarq_J_get", _wrap_CvLevMarq_J_get, METH_VARARGS, (char *)"CvLevMarq_J_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_err_set", _wrap_CvLevMarq_err_set, METH_VARARGS, (char *)"CvLevMarq_err_set(CvLevMarq self, CvMat err)"},
{ (char *)"CvLevMarq_err_get", _wrap_CvLevMarq_err_get, METH_VARARGS, (char *)"CvLevMarq_err_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_JtJ_set", _wrap_CvLevMarq_JtJ_set, METH_VARARGS, (char *)"CvLevMarq_JtJ_set(CvLevMarq self, CvMat JtJ)"},
{ (char *)"CvLevMarq_JtJ_get", _wrap_CvLevMarq_JtJ_get, METH_VARARGS, (char *)"CvLevMarq_JtJ_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_JtJN_set", _wrap_CvLevMarq_JtJN_set, METH_VARARGS, (char *)"CvLevMarq_JtJN_set(CvLevMarq self, CvMat JtJN)"},
{ (char *)"CvLevMarq_JtJN_get", _wrap_CvLevMarq_JtJN_get, METH_VARARGS, (char *)"CvLevMarq_JtJN_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_JtErr_set", _wrap_CvLevMarq_JtErr_set, METH_VARARGS, (char *)"CvLevMarq_JtErr_set(CvLevMarq self, CvMat JtErr)"},
{ (char *)"CvLevMarq_JtErr_get", _wrap_CvLevMarq_JtErr_get, METH_VARARGS, (char *)"CvLevMarq_JtErr_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_JtJV_set", _wrap_CvLevMarq_JtJV_set, METH_VARARGS, (char *)"CvLevMarq_JtJV_set(CvLevMarq self, CvMat JtJV)"},
{ (char *)"CvLevMarq_JtJV_get", _wrap_CvLevMarq_JtJV_get, METH_VARARGS, (char *)"CvLevMarq_JtJV_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_JtJW_set", _wrap_CvLevMarq_JtJW_set, METH_VARARGS, (char *)"CvLevMarq_JtJW_set(CvLevMarq self, CvMat JtJW)"},
{ (char *)"CvLevMarq_JtJW_get", _wrap_CvLevMarq_JtJW_get, METH_VARARGS, (char *)"CvLevMarq_JtJW_get(CvLevMarq self) -> CvMat"},
{ (char *)"CvLevMarq_prevErrNorm_set", _wrap_CvLevMarq_prevErrNorm_set, METH_VARARGS, (char *)"CvLevMarq_prevErrNorm_set(CvLevMarq self, double prevErrNorm)"},
{ (char *)"CvLevMarq_prevErrNorm_get", _wrap_CvLevMarq_prevErrNorm_get, METH_VARARGS, (char *)"CvLevMarq_prevErrNorm_get(CvLevMarq self) -> double"},
{ (char *)"CvLevMarq_errNorm_set", _wrap_CvLevMarq_errNorm_set, METH_VARARGS, (char *)"CvLevMarq_errNorm_set(CvLevMarq self, double errNorm)"},
{ (char *)"CvLevMarq_errNorm_get", _wrap_CvLevMarq_errNorm_get, METH_VARARGS, (char *)"CvLevMarq_errNorm_get(CvLevMarq self) -> double"},
{ (char *)"CvLevMarq_lambdaLg10_set", _wrap_CvLevMarq_lambdaLg10_set, METH_VARARGS, (char *)"CvLevMarq_lambdaLg10_set(CvLevMarq self, int lambdaLg10)"},
{ (char *)"CvLevMarq_lambdaLg10_get", _wrap_CvLevMarq_lambdaLg10_get, METH_VARARGS, (char *)"CvLevMarq_lambdaLg10_get(CvLevMarq self) -> int"},
{ (char *)"CvLevMarq_criteria_set", _wrap_CvLevMarq_criteria_set, METH_VARARGS, (char *)"CvLevMarq_criteria_set(CvLevMarq self, CvTermCriteria criteria)"},
{ (char *)"CvLevMarq_criteria_get", _wrap_CvLevMarq_criteria_get, METH_VARARGS, (char *)"CvLevMarq_criteria_get(CvLevMarq self) -> CvTermCriteria"},
{ (char *)"CvLevMarq_state_set", _wrap_CvLevMarq_state_set, METH_VARARGS, (char *)"CvLevMarq_state_set(CvLevMarq self, int state)"},
{ (char *)"CvLevMarq_state_get", _wrap_CvLevMarq_state_get, METH_VARARGS, (char *)"CvLevMarq_state_get(CvLevMarq self) -> int"},
{ (char *)"CvLevMarq_iters_set", _wrap_CvLevMarq_iters_set, METH_VARARGS, (char *)"CvLevMarq_iters_set(CvLevMarq self, int iters)"},
{ (char *)"CvLevMarq_iters_get", _wrap_CvLevMarq_iters_get, METH_VARARGS, (char *)"CvLevMarq_iters_get(CvLevMarq self) -> int"},
{ (char *)"CvLevMarq_completeSymmFlag_set", _wrap_CvLevMarq_completeSymmFlag_set, METH_VARARGS, (char *)"CvLevMarq_completeSymmFlag_set(CvLevMarq self, bool completeSymmFlag)"},
{ (char *)"CvLevMarq_completeSymmFlag_get", _wrap_CvLevMarq_completeSymmFlag_get, METH_VARARGS, (char *)"CvLevMarq_completeSymmFlag_get(CvLevMarq self) -> bool"},
{ (char *)"CvLevMarq_swigregister", CvLevMarq_swigregister, METH_VARARGS, NULL},
{ (char *)"CvTuple_CvPoint_2_val_set", _wrap_CvTuple_CvPoint_2_val_set, METH_VARARGS, (char *)"CvTuple_CvPoint_2_val_set(CvTuple_CvPoint_2 self, CvPoint val)"},
{ (char *)"CvTuple_CvPoint_2_val_get", _wrap_CvTuple_CvPoint_2_val_get, METH_VARARGS, (char *)"CvTuple_CvPoint_2_val_get(CvTuple_CvPoint_2 self) -> CvPoint"},
{ (char *)"CvTuple_CvPoint_2___setitem__", _wrap_CvTuple_CvPoint_2___setitem__, METH_VARARGS, (char *)"CvTuple_CvPoint_2___setitem__(CvTuple_CvPoint_2 self, int i, CvPoint obj)"},
{ (char *)"CvTuple_CvPoint_2___getitem__", _wrap_CvTuple_CvPoint_2___getitem__, METH_VARARGS, (char *)"CvTuple_CvPoint_2___getitem__(CvTuple_CvPoint_2 self, int i) -> CvPoint"},
{ (char *)"new_CvTuple_CvPoint_2", _wrap_new_CvTuple_CvPoint_2, METH_VARARGS, (char *)"new_CvTuple_CvPoint_2() -> CvTuple_CvPoint_2"},
{ (char *)"delete_CvTuple_CvPoint_2", _wrap_delete_CvTuple_CvPoint_2, METH_VARARGS, (char *)"delete_CvTuple_CvPoint_2(CvTuple_CvPoint_2 self)"},
{ (char *)"CvTuple_CvPoint_2_swigregister", CvTuple_CvPoint_2_swigregister, METH_VARARGS, NULL},
{ (char *)"CvTuple_float_2_val_set", _wrap_CvTuple_float_2_val_set, METH_VARARGS, (char *)"CvTuple_float_2_val_set(CvTuple_float_2 self, float val)"},
{ (char *)"CvTuple_float_2_val_get", _wrap_CvTuple_float_2_val_get, METH_VARARGS, (char *)"CvTuple_float_2_val_get(CvTuple_float_2 self) -> float"},
{ (char *)"CvTuple_float_2___setitem__", _wrap_CvTuple_float_2___setitem__, METH_VARARGS, (char *)"CvTuple_float_2___setitem__(CvTuple_float_2 self, int i, float obj)"},
{ (char *)"CvTuple_float_2___getitem__", _wrap_CvTuple_float_2___getitem__, METH_VARARGS, (char *)"CvTuple_float_2___getitem__(CvTuple_float_2 self, int i) -> float"},
{ (char *)"new_CvTuple_float_2", _wrap_new_CvTuple_float_2, METH_VARARGS, (char *)"new_CvTuple_float_2() -> CvTuple_float_2"},
{ (char *)"delete_CvTuple_float_2", _wrap_delete_CvTuple_float_2, METH_VARARGS, (char *)"delete_CvTuple_float_2(CvTuple_float_2 self)"},
{ (char *)"CvTuple_float_2_swigregister", CvTuple_float_2_swigregister, METH_VARARGS, NULL},
{ (char *)"CvTuple_float_3_val_set", _wrap_CvTuple_float_3_val_set, METH_VARARGS, (char *)"CvTuple_float_3_val_set(CvTuple_float_3 self, float val)"},
{ (char *)"CvTuple_float_3_val_get", _wrap_CvTuple_float_3_val_get, METH_VARARGS, (char *)"CvTuple_float_3_val_get(CvTuple_float_3 self) -> float"},
{ (char *)"CvTuple_float_3___setitem__", _wrap_CvTuple_float_3___setitem__, METH_VARARGS, (char *)"CvTuple_float_3___setitem__(CvTuple_float_3 self, int i, float obj)"},
{ (char *)"CvTuple_float_3___getitem__", _wrap_CvTuple_float_3___getitem__, METH_VARARGS, (char *)"CvTuple_float_3___getitem__(CvTuple_float_3 self, int i) -> float"},
{ (char *)"new_CvTuple_float_3", _wrap_new_CvTuple_float_3, METH_VARARGS, (char *)"new_CvTuple_float_3() -> CvTuple_float_3"},
{ (char *)"delete_CvTuple_float_3", _wrap_delete_CvTuple_float_3, METH_VARARGS, (char *)"delete_CvTuple_float_3(CvTuple_float_3 self)"},
{ (char *)"CvTuple_float_3_swigregister", CvTuple_float_3_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvPoint_cast", _wrap_CvSeq_CvPoint_cast, METH_VARARGS, (char *)"CvSeq_CvPoint_cast(CvSeq seq) -> CvSeq_CvPoint"},
{ (char *)"CvSeq_CvPoint___getitem__", _wrap_CvSeq_CvPoint___getitem__, METH_VARARGS, (char *)"CvSeq_CvPoint___getitem__(CvSeq_CvPoint self, int i) -> CvPoint"},
{ (char *)"CvSeq_CvPoint___setitem__", _wrap_CvSeq_CvPoint___setitem__, METH_VARARGS, (char *)"CvSeq_CvPoint___setitem__(CvSeq_CvPoint self, int i, CvPoint obj)"},
{ (char *)"CvSeq_CvPoint_append", _wrap_CvSeq_CvPoint_append, METH_VARARGS, (char *)"CvSeq_CvPoint_append(CvSeq_CvPoint self, CvPoint obj)"},
{ (char *)"CvSeq_CvPoint_pop", _wrap_CvSeq_CvPoint_pop, METH_VARARGS, (char *)"CvSeq_CvPoint_pop(CvSeq_CvPoint self) -> CvPoint"},
{ (char *)"new_CvSeq_CvPoint", _wrap_new_CvSeq_CvPoint, METH_VARARGS, (char *)"new_CvSeq_CvPoint() -> CvSeq_CvPoint"},
{ (char *)"delete_CvSeq_CvPoint", _wrap_delete_CvSeq_CvPoint, METH_VARARGS, (char *)"delete_CvSeq_CvPoint(CvSeq_CvPoint self)"},
{ (char *)"CvSeq_CvPoint_swigregister", CvSeq_CvPoint_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvPoint2D32f_cast", _wrap_CvSeq_CvPoint2D32f_cast, METH_VARARGS, (char *)"CvSeq_CvPoint2D32f_cast(CvSeq seq) -> CvSeq_CvPoint2D32f"},
{ (char *)"CvSeq_CvPoint2D32f___getitem__", _wrap_CvSeq_CvPoint2D32f___getitem__, METH_VARARGS, (char *)"CvSeq_CvPoint2D32f___getitem__(CvSeq_CvPoint2D32f self, int i) -> CvPoint2D32f"},
{ (char *)"CvSeq_CvPoint2D32f___setitem__", _wrap_CvSeq_CvPoint2D32f___setitem__, METH_VARARGS, (char *)"CvSeq_CvPoint2D32f___setitem__(CvSeq_CvPoint2D32f self, int i, CvPoint2D32f obj)"},
{ (char *)"CvSeq_CvPoint2D32f_append", _wrap_CvSeq_CvPoint2D32f_append, METH_VARARGS, (char *)"CvSeq_CvPoint2D32f_append(CvSeq_CvPoint2D32f self, CvPoint2D32f obj)"},
{ (char *)"CvSeq_CvPoint2D32f_pop", _wrap_CvSeq_CvPoint2D32f_pop, METH_VARARGS, (char *)"CvSeq_CvPoint2D32f_pop(CvSeq_CvPoint2D32f self) -> CvPoint2D32f"},
{ (char *)"new_CvSeq_CvPoint2D32f", _wrap_new_CvSeq_CvPoint2D32f, METH_VARARGS, (char *)"new_CvSeq_CvPoint2D32f() -> CvSeq_CvPoint2D32f"},
{ (char *)"delete_CvSeq_CvPoint2D32f", _wrap_delete_CvSeq_CvPoint2D32f, METH_VARARGS, (char *)"delete_CvSeq_CvPoint2D32f(CvSeq_CvPoint2D32f self)"},
{ (char *)"CvSeq_CvPoint2D32f_swigregister", CvSeq_CvPoint2D32f_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvRect_cast", _wrap_CvSeq_CvRect_cast, METH_VARARGS, (char *)"CvSeq_CvRect_cast(CvSeq seq) -> CvSeq_CvRect"},
{ (char *)"CvSeq_CvRect___getitem__", _wrap_CvSeq_CvRect___getitem__, METH_VARARGS, (char *)"CvSeq_CvRect___getitem__(CvSeq_CvRect self, int i) -> CvRect"},
{ (char *)"CvSeq_CvRect___setitem__", _wrap_CvSeq_CvRect___setitem__, METH_VARARGS, (char *)"CvSeq_CvRect___setitem__(CvSeq_CvRect self, int i, CvRect obj)"},
{ (char *)"CvSeq_CvRect_append", _wrap_CvSeq_CvRect_append, METH_VARARGS, (char *)"CvSeq_CvRect_append(CvSeq_CvRect self, CvRect obj)"},
{ (char *)"CvSeq_CvRect_pop", _wrap_CvSeq_CvRect_pop, METH_VARARGS, (char *)"CvSeq_CvRect_pop(CvSeq_CvRect self) -> CvRect"},
{ (char *)"new_CvSeq_CvRect", _wrap_new_CvSeq_CvRect, METH_VARARGS, (char *)"new_CvSeq_CvRect() -> CvSeq_CvRect"},
{ (char *)"delete_CvSeq_CvRect", _wrap_delete_CvSeq_CvRect, METH_VARARGS, (char *)"delete_CvSeq_CvRect(CvSeq_CvRect self)"},
{ (char *)"CvSeq_CvRect_swigregister", CvSeq_CvRect_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvSeq_cast", _wrap_CvSeq_CvSeq_cast, METH_VARARGS, (char *)"CvSeq_CvSeq_cast(CvSeq seq) -> CvSeq_CvSeq"},
{ (char *)"CvSeq_CvSeq___getitem__", _wrap_CvSeq_CvSeq___getitem__, METH_VARARGS, (char *)"CvSeq_CvSeq___getitem__(CvSeq_CvSeq self, int i) -> CvSeq"},
{ (char *)"CvSeq_CvSeq___setitem__", _wrap_CvSeq_CvSeq___setitem__, METH_VARARGS, (char *)"CvSeq_CvSeq___setitem__(CvSeq_CvSeq self, int i, CvSeq obj)"},
{ (char *)"CvSeq_CvSeq_append", _wrap_CvSeq_CvSeq_append, METH_VARARGS, (char *)"CvSeq_CvSeq_append(CvSeq_CvSeq self, CvSeq obj)"},
{ (char *)"CvSeq_CvSeq_pop", _wrap_CvSeq_CvSeq_pop, METH_VARARGS, (char *)"CvSeq_CvSeq_pop(CvSeq_CvSeq self) -> CvSeq"},
{ (char *)"new_CvSeq_CvSeq", _wrap_new_CvSeq_CvSeq, METH_VARARGS, (char *)"new_CvSeq_CvSeq() -> CvSeq_CvSeq"},
{ (char *)"delete_CvSeq_CvSeq", _wrap_delete_CvSeq_CvSeq, METH_VARARGS, (char *)"delete_CvSeq_CvSeq(CvSeq_CvSeq self)"},
{ (char *)"CvSeq_CvSeq_swigregister", CvSeq_CvSeq_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvQuadEdge2D_cast", _wrap_CvSeq_CvQuadEdge2D_cast, METH_VARARGS, (char *)"CvSeq_CvQuadEdge2D_cast(CvSeq seq) -> CvSeq_CvQuadEdge2D"},
{ (char *)"CvSeq_CvQuadEdge2D___getitem__", _wrap_CvSeq_CvQuadEdge2D___getitem__, METH_VARARGS, (char *)"CvSeq_CvQuadEdge2D___getitem__(CvSeq_CvQuadEdge2D self, int i) -> CvQuadEdge2D"},
{ (char *)"CvSeq_CvQuadEdge2D___setitem__", _wrap_CvSeq_CvQuadEdge2D___setitem__, METH_VARARGS, (char *)"CvSeq_CvQuadEdge2D___setitem__(CvSeq_CvQuadEdge2D self, int i, CvQuadEdge2D obj)"},
{ (char *)"CvSeq_CvQuadEdge2D_append", _wrap_CvSeq_CvQuadEdge2D_append, METH_VARARGS, (char *)"CvSeq_CvQuadEdge2D_append(CvSeq_CvQuadEdge2D self, CvQuadEdge2D obj)"},
{ (char *)"CvSeq_CvQuadEdge2D_pop", _wrap_CvSeq_CvQuadEdge2D_pop, METH_VARARGS, (char *)"CvSeq_CvQuadEdge2D_pop(CvSeq_CvQuadEdge2D self) -> CvQuadEdge2D"},
{ (char *)"new_CvSeq_CvQuadEdge2D", _wrap_new_CvSeq_CvQuadEdge2D, METH_VARARGS, (char *)"new_CvSeq_CvQuadEdge2D() -> CvSeq_CvQuadEdge2D"},
{ (char *)"delete_CvSeq_CvQuadEdge2D", _wrap_delete_CvSeq_CvQuadEdge2D, METH_VARARGS, (char *)"delete_CvSeq_CvQuadEdge2D(CvSeq_CvQuadEdge2D self)"},
{ (char *)"CvSeq_CvQuadEdge2D_swigregister", CvSeq_CvQuadEdge2D_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvConnectedComp_cast", _wrap_CvSeq_CvConnectedComp_cast, METH_VARARGS, (char *)"CvSeq_CvConnectedComp_cast(CvSeq seq) -> CvSeq_CvConnectedComp"},
{ (char *)"CvSeq_CvConnectedComp___getitem__", _wrap_CvSeq_CvConnectedComp___getitem__, METH_VARARGS, (char *)"CvSeq_CvConnectedComp___getitem__(CvSeq_CvConnectedComp self, int i) -> CvConnectedComp"},
{ (char *)"CvSeq_CvConnectedComp___setitem__", _wrap_CvSeq_CvConnectedComp___setitem__, METH_VARARGS, (char *)"CvSeq_CvConnectedComp___setitem__(CvSeq_CvConnectedComp self, int i, CvConnectedComp obj)"},
{ (char *)"CvSeq_CvConnectedComp_append", _wrap_CvSeq_CvConnectedComp_append, METH_VARARGS, (char *)"CvSeq_CvConnectedComp_append(CvSeq_CvConnectedComp self, CvConnectedComp obj)"},
{ (char *)"CvSeq_CvConnectedComp_pop", _wrap_CvSeq_CvConnectedComp_pop, METH_VARARGS, (char *)"CvSeq_CvConnectedComp_pop(CvSeq_CvConnectedComp self) -> CvConnectedComp"},
{ (char *)"new_CvSeq_CvConnectedComp", _wrap_new_CvSeq_CvConnectedComp, METH_VARARGS, (char *)"new_CvSeq_CvConnectedComp() -> CvSeq_CvConnectedComp"},
{ (char *)"delete_CvSeq_CvConnectedComp", _wrap_delete_CvSeq_CvConnectedComp, METH_VARARGS, (char *)"delete_CvSeq_CvConnectedComp(CvSeq_CvConnectedComp self)"},
{ (char *)"CvSeq_CvConnectedComp_swigregister", CvSeq_CvConnectedComp_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_CvPoint_2_cast", _wrap_CvSeq_CvPoint_2_cast, METH_VARARGS, (char *)"CvSeq_CvPoint_2_cast(CvSeq seq) -> CvSeq_CvPoint_2"},
{ (char *)"CvSeq_CvPoint_2___getitem__", _wrap_CvSeq_CvPoint_2___getitem__, METH_VARARGS, (char *)"CvSeq_CvPoint_2___getitem__(CvSeq_CvPoint_2 self, int i) -> CvTuple_CvPoint_2"},
{ (char *)"CvSeq_CvPoint_2___setitem__", _wrap_CvSeq_CvPoint_2___setitem__, METH_VARARGS, (char *)"CvSeq_CvPoint_2___setitem__(CvSeq_CvPoint_2 self, int i, CvTuple_CvPoint_2 obj)"},
{ (char *)"CvSeq_CvPoint_2_append", _wrap_CvSeq_CvPoint_2_append, METH_VARARGS, (char *)"CvSeq_CvPoint_2_append(CvSeq_CvPoint_2 self, CvTuple_CvPoint_2 obj)"},
{ (char *)"CvSeq_CvPoint_2_pop", _wrap_CvSeq_CvPoint_2_pop, METH_VARARGS, (char *)"CvSeq_CvPoint_2_pop(CvSeq_CvPoint_2 self) -> CvTuple_CvPoint_2"},
{ (char *)"new_CvSeq_CvPoint_2", _wrap_new_CvSeq_CvPoint_2, METH_VARARGS, (char *)"new_CvSeq_CvPoint_2() -> CvSeq_CvPoint_2"},
{ (char *)"delete_CvSeq_CvPoint_2", _wrap_delete_CvSeq_CvPoint_2, METH_VARARGS, (char *)"delete_CvSeq_CvPoint_2(CvSeq_CvPoint_2 self)"},
{ (char *)"CvSeq_CvPoint_2_swigregister", CvSeq_CvPoint_2_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_float_2_cast", _wrap_CvSeq_float_2_cast, METH_VARARGS, (char *)"CvSeq_float_2_cast(CvSeq seq) -> CvSeq_float_2"},
{ (char *)"CvSeq_float_2___getitem__", _wrap_CvSeq_float_2___getitem__, METH_VARARGS, (char *)"CvSeq_float_2___getitem__(CvSeq_float_2 self, int i) -> CvTuple_float_2"},
{ (char *)"CvSeq_float_2___setitem__", _wrap_CvSeq_float_2___setitem__, METH_VARARGS, (char *)"CvSeq_float_2___setitem__(CvSeq_float_2 self, int i, CvTuple_float_2 obj)"},
{ (char *)"CvSeq_float_2_append", _wrap_CvSeq_float_2_append, METH_VARARGS, (char *)"CvSeq_float_2_append(CvSeq_float_2 self, CvTuple_float_2 obj)"},
{ (char *)"CvSeq_float_2_pop", _wrap_CvSeq_float_2_pop, METH_VARARGS, (char *)"CvSeq_float_2_pop(CvSeq_float_2 self) -> CvTuple_float_2"},
{ (char *)"new_CvSeq_float_2", _wrap_new_CvSeq_float_2, METH_VARARGS, (char *)"new_CvSeq_float_2() -> CvSeq_float_2"},
{ (char *)"delete_CvSeq_float_2", _wrap_delete_CvSeq_float_2, METH_VARARGS, (char *)"delete_CvSeq_float_2(CvSeq_float_2 self)"},
{ (char *)"CvSeq_float_2_swigregister", CvSeq_float_2_swigregister, METH_VARARGS, NULL},
{ (char *)"CvSeq_float_3_cast", _wrap_CvSeq_float_3_cast, METH_VARARGS, (char *)"CvSeq_float_3_cast(CvSeq seq) -> CvSeq_float_3"},
{ (char *)"CvSeq_float_3___getitem__", _wrap_CvSeq_float_3___getitem__, METH_VARARGS, (char *)"CvSeq_float_3___getitem__(CvSeq_float_3 self, int i) -> CvTuple_float_3"},
{ (char *)"CvSeq_float_3___setitem__", _wrap_CvSeq_float_3___setitem__, METH_VARARGS, (char *)"CvSeq_float_3___setitem__(CvSeq_float_3 self, int i, CvTuple_float_3 obj)"},
{ (char *)"CvSeq_float_3_append", _wrap_CvSeq_float_3_append, METH_VARARGS, (char *)"CvSeq_float_3_append(CvSeq_float_3 self, CvTuple_float_3 obj)"},
{ (char *)"CvSeq_float_3_pop", _wrap_CvSeq_float_3_pop, METH_VARARGS, (char *)"CvSeq_float_3_pop(CvSeq_float_3 self) -> CvTuple_float_3"},
{ (char *)"new_CvSeq_float_3", _wrap_new_CvSeq_float_3, METH_VARARGS, (char *)"new_CvSeq_float_3() -> CvSeq_float_3"},
{ (char *)"delete_CvSeq_float_3", _wrap_delete_CvSeq_float_3, METH_VARARGS, (char *)"delete_CvSeq_float_3(CvSeq_float_3 self)"},
{ (char *)"CvSeq_float_3_swigregister", CvSeq_float_3_swigregister, METH_VARARGS, NULL},
{ (char *)"SendErrorToPython", _wrap_SendErrorToPython, METH_VARARGS, (char *)"\n"
"SendErrorToPython(int status, char func_name, char err_msg, char file_name, \n"
" int line, void ?) -> int\n"
""},
{ (char *)"function_ptr_generator", _wrap_function_ptr_generator, METH_VARARGS, (char *)"function_ptr_generator() -> CvErrorCallback"},
{ (char *)"void_ptr_generator", _wrap_void_ptr_generator, METH_VARARGS, (char *)"void_ptr_generator() -> void"},
{ (char *)"void_ptrptr_generator", _wrap_void_ptrptr_generator, METH_VARARGS, (char *)"void_ptrptr_generator() -> void"},
{ NULL, NULL, 0, NULL }
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
static void *_p_CvLaplaceFilterTo_p_CvSepFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSepFilter *) ((CvLaplaceFilter *) x));
}
static void *_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< CvPoint,2 > > **) x));
}
static void *_p_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< float,2 > > **) x));
}
static void *_p_p_CvTypedSeqT_CvConnectedComp_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvConnectedComp > **) x));
}
static void *_p_p_CvTypedSeqT_CvRect_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvRect > **) x));
}
static void *_p_p_CvTypedSeqT_CvPoint_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvPoint > **) x));
}
static void *_p_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< float,3 > > **) x));
}
static void *_p_p_CvTypedSeqT_CvSeq_p_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvSeq * > **) x));
}
static void *_p_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvQuadEdge2D > **) x));
}
static void *_p_p_CvTypedSeqT_CvPoint2D32f_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq **) ((CvTypedSeq< CvPoint2D32f > **) x));
}
static void *_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< CvPoint,2 > > *) x));
}
static void *_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< float,2 > > *) x));
}
static void *_p_CvTypedSeqT_CvConnectedComp_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvConnectedComp > *) x));
}
static void *_p_CvTypedSeqT_CvRect_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvRect > *) x));
}
static void *_p_CvTypedSeqT_CvPoint_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvPoint > *) x));
}
static void *_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< float,3 > > *) x));
}
static void *_p_CvTypedSeqT_CvSeq_p_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvSeq * > *) x));
}
static void *_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvQuadEdge2D > *) x));
}
static void *_p_CvTypedSeqT_CvPoint2D32f_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvSeq *) ((CvTypedSeq< CvPoint2D32f > *) x));
}
static void *_p_CvMorphologyTo_p_CvBaseImageFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvBaseImageFilter *) ((CvMorphology *) x));
}
static void *_p_CvSepFilterTo_p_CvBaseImageFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvBaseImageFilter *) ((CvSepFilter *) x));
}
static void *_p_CvLinearFilterTo_p_CvBaseImageFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvBaseImageFilter *) ((CvLinearFilter *) x));
}
static void *_p_CvBoxFilterTo_p_CvBaseImageFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvBaseImageFilter *) ((CvBoxFilter *) x));
}
static void *_p_CvLaplaceFilterTo_p_CvBaseImageFilter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((CvBaseImageFilter *) (CvSepFilter *) ((CvLaplaceFilter *) x));
}
static swig_type_info _swigt__p_Cv32suf = {"_p_Cv32suf", "Cv32suf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Cv64suf = {"_p_Cv64suf", "Cv64suf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvAttrList = {"_p_CvAttrList", "CvAttrList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvAvgComp = {"_p_CvAvgComp", "CvAvgComp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvBaseImageFilter = {"_p_CvBaseImageFilter", "CvBaseImageFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvBox2D = {"_p_CvBox2D", "CvBox2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvBoxFilter = {"_p_CvBoxFilter", "CvBoxFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvChain = {"_p_CvChain", "CvChain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvChainPtReader = {"_p_CvChainPtReader", "CvChainPtReader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvConDensation = {"_p_CvConDensation", "CvConDensation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvConnectedComp = {"_p_CvConnectedComp", "CvConnectedComp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvContour = {"_p_CvContour", "CvPoint2DSeq *|CvContour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvContourTree = {"_p_CvContourTree", "CvContourTree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvConvexityDefect = {"_p_CvConvexityDefect", "CvConvexityDefect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFeatureTree = {"_p_CvFeatureTree", "CvFeatureTree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFileNode = {"_p_CvFileNode", "CvFileNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFileNode_data = {"_p_CvFileNode_data", "CvFileNode_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFileStorage = {"_p_CvFileStorage", "CvFileStorage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFilter = {"_p_CvFilter", "enum CvFilter *|CvFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvFont = {"_p_CvFont", "CvFont *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGenericHash = {"_p_CvGenericHash", "CvGenericHash *|CvFileNodeHash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGraph = {"_p_CvGraph", "CvGraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGraphEdge = {"_p_CvGraphEdge", "CvGraphEdge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGraphScanner = {"_p_CvGraphScanner", "CvGraphScanner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGraphVtx = {"_p_CvGraphVtx", "CvGraphVtx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvGraphVtx2D = {"_p_CvGraphVtx2D", "CvGraphVtx2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHaarClassifier = {"_p_CvHaarClassifier", "CvHaarClassifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHaarClassifierCascade = {"_p_CvHaarClassifierCascade", "CvHaarClassifierCascade *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHaarFeature = {"_p_CvHaarFeature", "CvHaarFeature *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHaarFeature_rect = {"_p_CvHaarFeature_rect", "CvHaarFeature_rect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHaarStageClassifier = {"_p_CvHaarStageClassifier", "CvHaarStageClassifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHidHaarClassifierCascade = {"_p_CvHidHaarClassifierCascade", "CvHidHaarClassifierCascade *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHistogram = {"_p_CvHistogram", "CvHistogram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvHuMoments = {"_p_CvHuMoments", "CvHuMoments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvImage = {"_p_CvImage", "CvImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvKalman = {"_p_CvKalman", "CvKalman *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvLaplaceFilter = {"_p_CvLaplaceFilter", "CvLaplaceFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvLevMarq = {"_p_CvLevMarq", "CvLevMarq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvLineIterator = {"_p_CvLineIterator", "CvLineIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvLinearFilter = {"_p_CvLinearFilter", "CvLinearFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMat = {"_p_CvMat", "CvMat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMatND = {"_p_CvMatND", "CvMatND *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMatND_data = {"_p_CvMatND_data", "CvMatND_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMatND_dim = {"_p_CvMatND_dim", "CvMatND_dim *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMat_data = {"_p_CvMat_data", "CvMat_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMatrix = {"_p_CvMatrix", "CvMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMatrix3 = {"_p_CvMatrix3", "CvMatrix3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMemBlock = {"_p_CvMemBlock", "CvMemBlock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMemStorage = {"_p_CvMemStorage", "CvMemStorage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMemStoragePos = {"_p_CvMemStoragePos", "CvMemStoragePos *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvModule = {"_p_CvModule", "CvModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvModuleInfo = {"_p_CvModuleInfo", "CvModuleInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMoments = {"_p_CvMoments", "CvMoments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvMorphology = {"_p_CvMorphology", "CvMorphology *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvNArrayIterator = {"_p_CvNArrayIterator", "CvNArrayIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvNextEdgeType = {"_p_CvNextEdgeType", "enum CvNextEdgeType *|CvNextEdgeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPOSITObject = {"_p_CvPOSITObject", "CvPOSITObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPluginFuncInfo = {"_p_CvPluginFuncInfo", "CvPluginFuncInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPoint = {"_p_CvPoint", "CvPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPoint2D32f = {"_p_CvPoint2D32f", "CvPoint2D32f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPoint2D64f = {"_p_CvPoint2D64f", "CvPoint2D64f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPoint3D32f = {"_p_CvPoint3D32f", "CvPoint3D32f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvPoint3D64f = {"_p_CvPoint3D64f", "CvPoint3D64f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvQuadEdge2D = {"_p_CvQuadEdge2D", "CvQuadEdge2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvRNG_Wrapper = {"_p_CvRNG_Wrapper", "CvRNG_Wrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvRandState = {"_p_CvRandState", "CvRandState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvRect = {"_p_CvRect", "CvRect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSURFParams = {"_p_CvSURFParams", "CvSURFParams *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSURFPoint = {"_p_CvSURFPoint", "CvSURFPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvScalar = {"_p_CvScalar", "CvScalar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSepFilter = {"_p_CvSepFilter", "CvSepFilter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSeq = {"_p_CvSeq", "CvSeq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSeqBlock = {"_p_CvSeqBlock", "CvSeqBlock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSeqReader = {"_p_CvSeqReader", "CvSeqReader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSeqWriter = {"_p_CvSeqWriter", "CvSeqWriter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSet = {"_p_CvSet", "CvSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSetElem = {"_p_CvSetElem", "CvSetElem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSize = {"_p_CvSize", "CvSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSize2D32f = {"_p_CvSize2D32f", "CvSize2D32f *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSlice = {"_p_CvSlice", "CvSlice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSparseMat = {"_p_CvSparseMat", "CvSparseMat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSparseMatIterator = {"_p_CvSparseMatIterator", "CvSparseMatIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSparseNode = {"_p_CvSparseNode", "CvSparseNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvStereoBMState = {"_p_CvStereoBMState", "CvStereoBMState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvStereoGCState = {"_p_CvStereoGCState", "CvStereoGCState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvString = {"_p_CvString", "CvString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvStringHashNode = {"_p_CvStringHashNode", "CvStringHashNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSubdiv2D = {"_p_CvSubdiv2D", "CvSubdiv2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSubdiv2DEdge_Wrapper = {"_p_CvSubdiv2DEdge_Wrapper", "CvSubdiv2DEdge_Wrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSubdiv2DPoint = {"_p_CvSubdiv2DPoint", "CvSubdiv2DPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvSubdiv2DPointLocation = {"_p_CvSubdiv2DPointLocation", "enum CvSubdiv2DPointLocation *|CvSubdiv2DPointLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTermCriteria = {"_p_CvTermCriteria", "CvTermCriteria *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTreeNodeIterator = {"_p_CvTreeNodeIterator", "CvTreeNodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTupleT_CvPoint_2_t = {"_p_CvTupleT_CvPoint_2_t", "CvTuple< CvPoint,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTupleT_float_2_t = {"_p_CvTupleT_float_2_t", "CvTuple< float,2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTupleT_float_3_t = {"_p_CvTupleT_float_3_t", "CvTuple< float,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvType = {"_p_CvType", "CvType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypeInfo = {"_p_CvTypeInfo", "CvTypeInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvConnectedComp_t = {"_p_CvTypedSeqT_CvConnectedComp_t", "CvTypedSeq< CvConnectedComp > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvPoint2D32f_t = {"_p_CvTypedSeqT_CvPoint2D32f_t", "CvTypedSeq< CvPoint2D32f > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvPoint_t = {"_p_CvTypedSeqT_CvPoint_t", "CvTypedSeq< CvPoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvQuadEdge2D_t = {"_p_CvTypedSeqT_CvQuadEdge2D_t", "CvTypedSeq< CvQuadEdge2D > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvRect_t = {"_p_CvTypedSeqT_CvRect_t", "CvTypedSeq< CvRect > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvSeq_p_t = {"_p_CvTypedSeqT_CvSeq_p_t", "CvTypedSeq< CvSeq * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t = {"_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t", "CvTypedSeq< CvTuple< CvPoint,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t = {"_p_CvTypedSeqT_CvTupleT_float_2_t_t", "CvTypedSeq< CvTuple< float,2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t = {"_p_CvTypedSeqT_CvTupleT_float_3_t_t", "CvTypedSeq< CvTuple< float,3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__CvContourScanner = {"_p__CvContourScanner", "_CvContourScanner *|CvContourScanner", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IplConvKernel = {"_p__IplConvKernel", "_IplConvKernel *|IplConvKernel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IplConvKernelFP = {"_p__IplConvKernelFP", "_IplConvKernelFP *|IplConvKernelFP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IplImage = {"_p__IplImage", "_IplImage *|IplImage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IplROI = {"_p__IplROI", "_IplROI *|IplROI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__IplTileInfo = {"_p__IplTileInfo", "_IplTileInfo *|IplTileInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__float = {"_p_a_2__float", "float (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__signed_char = {"_p_a_2__signed_char", "signed char (*)[2]|schar (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__float = {"_p_a_3__float", "float (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_int_int_int__p__IplROI = {"_p_f_int_int_int_int_int__p__IplROI", "Cv_iplCreateROI|_IplROI *(*)(int,int,int,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage = {"_p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage", "_IplImage *(*)(int,int,int,char *,char *,int,int,int,int,int,IplROI *,IplImage *,void *,IplTileInfo *)|Cv_iplCreateImageHeader", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int = {"_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int", "int (*)(int,char const *,char const *,char const *,int,void *)|CvErrorCallback", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void = {"_p_f_p_CvFileStorage_p_CvFileNode__p_void", "void *(*)(CvFileStorage *,CvFileNode *)|CvReadFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void = {"_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void", "void (*)(CvFileStorage *,char const *,void const *,CvAttrList)|CvWriteFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__IplImage_int__void = {"_p_f_p__IplImage_int__void", "Cv_iplDeallocate|void (*)(_IplImage *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__IplImage_int_int__void = {"_p_f_p__IplImage_int_int__void", "Cv_iplAllocateImageData|void (*)(_IplImage *,int,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void = {"_p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void", "void (*)(unsigned char **,unsigned char *,int,int,void *)|CvColumnFilterFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_p_void__void = {"_p_f_p_p_void__void", "void (*)(void **)|CvReleaseFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__IplImage__p__IplImage = {"_p_f_p_q_const__IplImage__p__IplImage", "_IplImage *(*)(IplImage const *)|Cv_iplCloneImage", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_int__p_CvMat = {"_p_f_p_q_const__char_int__p_CvMat", "CvMat *(*)(char const *,int)|CvLoadImageMFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_int__p__IplImage = {"_p_f_p_q_const__char_int__p__IplImage", "CvLoadImageFunc|_IplImage *(*)(char const *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__void__int = {"_p_f_p_q_const__char_p_q_const__void__int", "CvSaveImageFunc|int (*)(char const *,void const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__void__void = {"_p_f_p_q_const__char_p_q_const__void__void", "CvShowImageFunc|void (*)(char const *,void const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__float_p_q_const__float_p_void__float = {"_p_f_p_q_const__float_p_q_const__float_p_void__float", "CvDistanceFunction|float (*)(float const *,float const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void = {"_p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void", "CvRowFilterFunc|void (*)(unsigned char const *,unsigned char *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__void__int = {"_p_f_p_q_const__void__int", "CvIsInstanceFunc|int (*)(void const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__void__p_void = {"_p_f_p_q_const__void__p_void", "CvCloneFunc|void *(*)(void const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__void_p_q_const__void_p_void__int = {"_p_f_p_q_const__void_p_q_const__void_p_void__int", "CvCmpFunc|int (*)(void const *,void const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void__int = {"_p_f_p_void_p_void__int", "int (*)(void *,void *)|CvFreeFunc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_size_t_p_void__p_void = {"_p_f_size_t_p_void__p_void", "CvAllocFunc|void *(*)(size_t,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *|CvVect32f|CvMatr32f", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "CvHistType *|int *|CVStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64 *|int64 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvGraphEdge = {"_p_p_CvGraphEdge", "CvGraphEdge **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvGraphVtx = {"_p_p_CvGraphVtx", "CvGraphVtx **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvHistogram = {"_p_p_CvHistogram", "CvHistogram **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvMat = {"_p_p_CvMat", "CvMat **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvMatND = {"_p_p_CvMatND", "CvMatND **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvPoint = {"_p_p_CvPoint", "CvPoint **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvSeq = {"_p_p_CvSeq", "CvSeq **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t = {"_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t = {"_p_p_CvTypedSeqT_CvTupleT_float_2_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvRect_t = {"_p_p_CvTypedSeqT_CvRect_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvPoint_t = {"_p_p_CvTypedSeqT_CvPoint_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t = {"_p_p_CvTypedSeqT_CvQuadEdge2D_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvSeq_p_t = {"_p_p_CvTypedSeqT_CvSeq_p_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvPoint2D32f_t = {"_p_p_CvTypedSeqT_CvPoint2D32f_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t = {"_p_p_CvTypedSeqT_CvTupleT_float_3_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvTypedSeqT_CvConnectedComp_t = {"_p_p_CvTypedSeqT_CvConnectedComp_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_CvSeqBlock = {"_p_p_CvSeqBlock", "CvSeqBlock **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvSetElem = {"_p_p_CvSetElem", "CvSetElem **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvStereoBMState = {"_p_p_CvStereoBMState", "CvStereoBMState **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvStereoGCState = {"_p_p_CvStereoGCState", "CvStereoGCState **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_CvSubdiv2DPoint = {"_p_p_CvSubdiv2DPoint", "CvSubdiv2DPoint **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__CvContourScanner = {"_p_p__CvContourScanner", "CvContourScanner *|_CvContourScanner **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__IplImage = {"_p_p__IplImage", "_IplImage **|IplImage **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_p_CvMat = {"_p_p_p_CvMat", "CvMat ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "unsigned char **|uchar **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **|CvArr **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "schar *|signed char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *|CvSubdiv2DEdge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t", "std::vector< CvPoint,std::allocator< CvPoint > > *|std::vector< CvPoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type", "std::vector< CvPoint >::allocator_type *|std::allocator< CvPoint > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type", "std::vector< CvPoint >::value_type *|CvPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_float_std__allocatorT_float_t_t = {"_p_std__vectorT_float_std__allocatorT_float_t_t", "std::vector< float > *|std::vector< float,std::allocator< float > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type = {"_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type", "std::vector< float >::allocator_type *|std::allocator< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uchar *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64 *|uint64 *|CvRNG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|ushort *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "CvArr *|void *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_Cv32suf,
&_swigt__p_Cv64suf,
&_swigt__p_CvAttrList,
&_swigt__p_CvAvgComp,
&_swigt__p_CvBaseImageFilter,
&_swigt__p_CvBox2D,
&_swigt__p_CvBoxFilter,
&_swigt__p_CvChain,
&_swigt__p_CvChainPtReader,
&_swigt__p_CvConDensation,
&_swigt__p_CvConnectedComp,
&_swigt__p_CvContour,
&_swigt__p_CvContourTree,
&_swigt__p_CvConvexityDefect,
&_swigt__p_CvFeatureTree,
&_swigt__p_CvFileNode,
&_swigt__p_CvFileNode_data,
&_swigt__p_CvFileStorage,
&_swigt__p_CvFilter,
&_swigt__p_CvFont,
&_swigt__p_CvGenericHash,
&_swigt__p_CvGraph,
&_swigt__p_CvGraphEdge,
&_swigt__p_CvGraphScanner,
&_swigt__p_CvGraphVtx,
&_swigt__p_CvGraphVtx2D,
&_swigt__p_CvHaarClassifier,
&_swigt__p_CvHaarClassifierCascade,
&_swigt__p_CvHaarFeature,
&_swigt__p_CvHaarFeature_rect,
&_swigt__p_CvHaarStageClassifier,
&_swigt__p_CvHidHaarClassifierCascade,
&_swigt__p_CvHistogram,
&_swigt__p_CvHuMoments,
&_swigt__p_CvImage,
&_swigt__p_CvKalman,
&_swigt__p_CvLaplaceFilter,
&_swigt__p_CvLevMarq,
&_swigt__p_CvLineIterator,
&_swigt__p_CvLinearFilter,
&_swigt__p_CvMat,
&_swigt__p_CvMatND,
&_swigt__p_CvMatND_data,
&_swigt__p_CvMatND_dim,
&_swigt__p_CvMat_data,
&_swigt__p_CvMatrix,
&_swigt__p_CvMatrix3,
&_swigt__p_CvMemBlock,
&_swigt__p_CvMemStorage,
&_swigt__p_CvMemStoragePos,
&_swigt__p_CvModule,
&_swigt__p_CvModuleInfo,
&_swigt__p_CvMoments,
&_swigt__p_CvMorphology,
&_swigt__p_CvNArrayIterator,
&_swigt__p_CvNextEdgeType,
&_swigt__p_CvPOSITObject,
&_swigt__p_CvPluginFuncInfo,
&_swigt__p_CvPoint,
&_swigt__p_CvPoint2D32f,
&_swigt__p_CvPoint2D64f,
&_swigt__p_CvPoint3D32f,
&_swigt__p_CvPoint3D64f,
&_swigt__p_CvQuadEdge2D,
&_swigt__p_CvRNG_Wrapper,
&_swigt__p_CvRandState,
&_swigt__p_CvRect,
&_swigt__p_CvSURFParams,
&_swigt__p_CvSURFPoint,
&_swigt__p_CvScalar,
&_swigt__p_CvSepFilter,
&_swigt__p_CvSeq,
&_swigt__p_CvSeqBlock,
&_swigt__p_CvSeqReader,
&_swigt__p_CvSeqWriter,
&_swigt__p_CvSet,
&_swigt__p_CvSetElem,
&_swigt__p_CvSize,
&_swigt__p_CvSize2D32f,
&_swigt__p_CvSlice,
&_swigt__p_CvSparseMat,
&_swigt__p_CvSparseMatIterator,
&_swigt__p_CvSparseNode,
&_swigt__p_CvStereoBMState,
&_swigt__p_CvStereoGCState,
&_swigt__p_CvString,
&_swigt__p_CvStringHashNode,
&_swigt__p_CvSubdiv2D,
&_swigt__p_CvSubdiv2DEdge_Wrapper,
&_swigt__p_CvSubdiv2DPoint,
&_swigt__p_CvSubdiv2DPointLocation,
&_swigt__p_CvTermCriteria,
&_swigt__p_CvTreeNodeIterator,
&_swigt__p_CvTupleT_CvPoint_2_t,
&_swigt__p_CvTupleT_float_2_t,
&_swigt__p_CvTupleT_float_3_t,
&_swigt__p_CvType,
&_swigt__p_CvTypeInfo,
&_swigt__p_CvTypedSeqT_CvConnectedComp_t,
&_swigt__p_CvTypedSeqT_CvPoint2D32f_t,
&_swigt__p_CvTypedSeqT_CvPoint_t,
&_swigt__p_CvTypedSeqT_CvQuadEdge2D_t,
&_swigt__p_CvTypedSeqT_CvRect_t,
&_swigt__p_CvTypedSeqT_CvSeq_p_t,
&_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t,
&_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t,
&_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t,
&_swigt__p__CvContourScanner,
&_swigt__p__IplConvKernel,
&_swigt__p__IplConvKernelFP,
&_swigt__p__IplImage,
&_swigt__p__IplROI,
&_swigt__p__IplTileInfo,
&_swigt__p_a_2__float,
&_swigt__p_a_2__signed_char,
&_swigt__p_a_3__float,
&_swigt__p_allocator_type,
&_swigt__p_char,
&_swigt__p_difference_type,
&_swigt__p_double,
&_swigt__p_f_int_int_int_int_int__p__IplROI,
&_swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage,
&_swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int,
&_swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void,
&_swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void,
&_swigt__p_f_p__IplImage_int__void,
&_swigt__p_f_p__IplImage_int_int__void,
&_swigt__p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void,
&_swigt__p_f_p_p_void__void,
&_swigt__p_f_p_q_const__IplImage__p__IplImage,
&_swigt__p_f_p_q_const__char_int__p_CvMat,
&_swigt__p_f_p_q_const__char_int__p__IplImage,
&_swigt__p_f_p_q_const__char_p_q_const__void__int,
&_swigt__p_f_p_q_const__char_p_q_const__void__void,
&_swigt__p_f_p_q_const__float_p_q_const__float_p_void__float,
&_swigt__p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void,
&_swigt__p_f_p_q_const__void__int,
&_swigt__p_f_p_q_const__void__p_void,
&_swigt__p_f_p_q_const__void_p_q_const__void_p_void__int,
&_swigt__p_f_p_void_p_void__int,
&_swigt__p_f_size_t_p_void__p_void,
&_swigt__p_float,
&_swigt__p_int,
&_swigt__p_long_long,
&_swigt__p_p_CvGraphEdge,
&_swigt__p_p_CvGraphVtx,
&_swigt__p_p_CvHistogram,
&_swigt__p_p_CvMat,
&_swigt__p_p_CvMatND,
&_swigt__p_p_CvPoint,
&_swigt__p_p_CvSeq,
&_swigt__p_p_CvSeqBlock,
&_swigt__p_p_CvSetElem,
&_swigt__p_p_CvStereoBMState,
&_swigt__p_p_CvStereoGCState,
&_swigt__p_p_CvSubdiv2DPoint,
&_swigt__p_p_CvTypedSeqT_CvConnectedComp_t,
&_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t,
&_swigt__p_p_CvTypedSeqT_CvPoint_t,
&_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t,
&_swigt__p_p_CvTypedSeqT_CvRect_t,
&_swigt__p_p_CvTypedSeqT_CvSeq_p_t,
&_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t,
&_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t,
&_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t,
&_swigt__p_p_PyObject,
&_swigt__p_p__CvContourScanner,
&_swigt__p_p__IplImage,
&_swigt__p_p_char,
&_swigt__p_p_double,
&_swigt__p_p_float,
&_swigt__p_p_p_CvMat,
&_swigt__p_p_unsigned_char,
&_swigt__p_p_void,
&_swigt__p_short,
&_swigt__p_signed_char,
&_swigt__p_size_t,
&_swigt__p_size_type,
&_swigt__p_std__invalid_argument,
&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t,
&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type,
&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type,
&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t,
&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type,
&_swigt__p_swig__PySwigIterator,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
&_swigt__p_value_type,
&_swigt__p_void,
};
static swig_cast_info _swigc__p_Cv32suf[] = { {&_swigt__p_Cv32suf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Cv64suf[] = { {&_swigt__p_Cv64suf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvAttrList[] = { {&_swigt__p_CvAttrList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvAvgComp[] = { {&_swigt__p_CvAvgComp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvBaseImageFilter[] = { {&_swigt__p_CvMorphology, _p_CvMorphologyTo_p_CvBaseImageFilter, 0, 0}, {&_swigt__p_CvSepFilter, _p_CvSepFilterTo_p_CvBaseImageFilter, 0, 0}, {&_swigt__p_CvLinearFilter, _p_CvLinearFilterTo_p_CvBaseImageFilter, 0, 0}, {&_swigt__p_CvBoxFilter, _p_CvBoxFilterTo_p_CvBaseImageFilter, 0, 0}, {&_swigt__p_CvBaseImageFilter, 0, 0, 0}, {&_swigt__p_CvLaplaceFilter, _p_CvLaplaceFilterTo_p_CvBaseImageFilter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvBox2D[] = { {&_swigt__p_CvBox2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvBoxFilter[] = { {&_swigt__p_CvBoxFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvChain[] = { {&_swigt__p_CvChain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvChainPtReader[] = { {&_swigt__p_CvChainPtReader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvConDensation[] = { {&_swigt__p_CvConDensation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvConnectedComp[] = { {&_swigt__p_CvConnectedComp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvContour[] = { {&_swigt__p_CvContour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvContourTree[] = { {&_swigt__p_CvContourTree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvConvexityDefect[] = { {&_swigt__p_CvConvexityDefect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFeatureTree[] = { {&_swigt__p_CvFeatureTree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFileNode[] = { {&_swigt__p_CvFileNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFileNode_data[] = { {&_swigt__p_CvFileNode_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFileStorage[] = { {&_swigt__p_CvFileStorage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFilter[] = { {&_swigt__p_CvFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvFont[] = { {&_swigt__p_CvFont, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGenericHash[] = { {&_swigt__p_CvGenericHash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGraph[] = { {&_swigt__p_CvGraph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGraphEdge[] = { {&_swigt__p_CvGraphEdge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGraphScanner[] = { {&_swigt__p_CvGraphScanner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGraphVtx[] = { {&_swigt__p_CvGraphVtx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvGraphVtx2D[] = { {&_swigt__p_CvGraphVtx2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHaarClassifier[] = { {&_swigt__p_CvHaarClassifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHaarClassifierCascade[] = { {&_swigt__p_CvHaarClassifierCascade, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHaarFeature[] = { {&_swigt__p_CvHaarFeature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHaarFeature_rect[] = { {&_swigt__p_CvHaarFeature_rect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHaarStageClassifier[] = { {&_swigt__p_CvHaarStageClassifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHidHaarClassifierCascade[] = { {&_swigt__p_CvHidHaarClassifierCascade, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHistogram[] = { {&_swigt__p_CvHistogram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvHuMoments[] = { {&_swigt__p_CvHuMoments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvImage[] = { {&_swigt__p_CvImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvKalman[] = { {&_swigt__p_CvKalman, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvLaplaceFilter[] = { {&_swigt__p_CvLaplaceFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvLevMarq[] = { {&_swigt__p_CvLevMarq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvLineIterator[] = { {&_swigt__p_CvLineIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvLinearFilter[] = { {&_swigt__p_CvLinearFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMat[] = { {&_swigt__p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMatND[] = { {&_swigt__p_CvMatND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMatND_data[] = { {&_swigt__p_CvMatND_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMatND_dim[] = { {&_swigt__p_CvMatND_dim, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMat_data[] = { {&_swigt__p_CvMat_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMatrix[] = { {&_swigt__p_CvMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMatrix3[] = { {&_swigt__p_CvMatrix3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMemBlock[] = { {&_swigt__p_CvMemBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMemStorage[] = { {&_swigt__p_CvMemStorage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMemStoragePos[] = { {&_swigt__p_CvMemStoragePos, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvModule[] = { {&_swigt__p_CvModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvModuleInfo[] = { {&_swigt__p_CvModuleInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMoments[] = { {&_swigt__p_CvMoments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvMorphology[] = { {&_swigt__p_CvMorphology, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvNArrayIterator[] = { {&_swigt__p_CvNArrayIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvNextEdgeType[] = { {&_swigt__p_CvNextEdgeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPOSITObject[] = { {&_swigt__p_CvPOSITObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPluginFuncInfo[] = { {&_swigt__p_CvPluginFuncInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPoint[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0, 0, 0}, {&_swigt__p_CvPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPoint2D32f[] = { {&_swigt__p_CvPoint2D32f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPoint2D64f[] = { {&_swigt__p_CvPoint2D64f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPoint3D32f[] = { {&_swigt__p_CvPoint3D32f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvPoint3D64f[] = { {&_swigt__p_CvPoint3D64f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvQuadEdge2D[] = { {&_swigt__p_CvQuadEdge2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvRNG_Wrapper[] = { {&_swigt__p_CvRNG_Wrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvRandState[] = { {&_swigt__p_CvRandState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvRect[] = { {&_swigt__p_CvRect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSURFParams[] = { {&_swigt__p_CvSURFParams, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSURFPoint[] = { {&_swigt__p_CvSURFPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvScalar[] = { {&_swigt__p_CvScalar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSepFilter[] = { {&_swigt__p_CvSepFilter, 0, 0, 0}, {&_swigt__p_CvLaplaceFilter, _p_CvLaplaceFilterTo_p_CvSepFilter, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSeq[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, _p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t, _p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvRect_t, _p_CvTypedSeqT_CvRect_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvPoint_t, _p_CvTypedSeqT_CvPoint_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvQuadEdge2D_t, _p_CvTypedSeqT_CvQuadEdge2D_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvSeq_p_t, _p_CvTypedSeqT_CvSeq_p_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvPoint2D32f_t, _p_CvTypedSeqT_CvPoint2D32f_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvSeq, 0, 0, 0}, {&_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t, _p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvConnectedComp_t, _p_CvTypedSeqT_CvConnectedComp_tTo_p_CvSeq, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSeqBlock[] = { {&_swigt__p_CvSeqBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSeqReader[] = { {&_swigt__p_CvSeqReader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSeqWriter[] = { {&_swigt__p_CvSeqWriter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSet[] = { {&_swigt__p_CvSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSetElem[] = { {&_swigt__p_CvSetElem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSize[] = { {&_swigt__p_CvSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSize2D32f[] = { {&_swigt__p_CvSize2D32f, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSlice[] = { {&_swigt__p_CvSlice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSparseMat[] = { {&_swigt__p_CvSparseMat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSparseMatIterator[] = { {&_swigt__p_CvSparseMatIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSparseNode[] = { {&_swigt__p_CvSparseNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvStereoBMState[] = { {&_swigt__p_CvStereoBMState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvStereoGCState[] = { {&_swigt__p_CvStereoGCState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvString[] = { {&_swigt__p_CvString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvStringHashNode[] = { {&_swigt__p_CvStringHashNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSubdiv2D[] = { {&_swigt__p_CvSubdiv2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSubdiv2DEdge_Wrapper[] = { {&_swigt__p_CvSubdiv2DEdge_Wrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSubdiv2DPoint[] = { {&_swigt__p_CvSubdiv2DPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvSubdiv2DPointLocation[] = { {&_swigt__p_CvSubdiv2DPointLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTermCriteria[] = { {&_swigt__p_CvTermCriteria, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTreeNodeIterator[] = { {&_swigt__p_CvTreeNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTupleT_CvPoint_2_t[] = { {&_swigt__p_CvTupleT_CvPoint_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTupleT_float_2_t[] = { {&_swigt__p_CvTupleT_float_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTupleT_float_3_t[] = { {&_swigt__p_CvTupleT_float_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvType[] = { {&_swigt__p_CvType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypeInfo[] = { {&_swigt__p_CvTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvConnectedComp_t[] = { {&_swigt__p_CvTypedSeqT_CvConnectedComp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvPoint2D32f_t[] = { {&_swigt__p_CvTypedSeqT_CvPoint2D32f_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvPoint_t[] = { {&_swigt__p_CvTypedSeqT_CvPoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvQuadEdge2D_t[] = { {&_swigt__p_CvTypedSeqT_CvQuadEdge2D_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvRect_t[] = { {&_swigt__p_CvTypedSeqT_CvRect_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvSeq_p_t[] = { {&_swigt__p_CvTypedSeqT_CvSeq_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_float_2_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_float_3_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__CvContourScanner[] = { {&_swigt__p__CvContourScanner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IplConvKernel[] = { {&_swigt__p__IplConvKernel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IplConvKernelFP[] = { {&_swigt__p__IplConvKernelFP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IplImage[] = { {&_swigt__p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IplROI[] = { {&_swigt__p__IplROI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__IplTileInfo[] = { {&_swigt__p__IplTileInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__float[] = { {&_swigt__p_a_2__float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__signed_char[] = { {&_swigt__p_a_2__signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__float[] = { {&_swigt__p_a_3__float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_int_int_int_int__p__IplROI[] = { {&_swigt__p_f_int_int_int_int_int__p__IplROI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage[] = { {&_swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int[] = { {&_swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_CvFileStorage_p_CvFileNode__p_void[] = { {&_swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void[] = { {&_swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__IplImage_int__void[] = { {&_swigt__p_f_p__IplImage_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__IplImage_int_int__void[] = { {&_swigt__p_f_p__IplImage_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void[] = { {&_swigt__p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_p_void__void[] = { {&_swigt__p_f_p_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__IplImage__p__IplImage[] = { {&_swigt__p_f_p_q_const__IplImage__p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_int__p_CvMat[] = { {&_swigt__p_f_p_q_const__char_int__p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_int__p__IplImage[] = { {&_swigt__p_f_p_q_const__char_int__p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__void__int[] = { {&_swigt__p_f_p_q_const__char_p_q_const__void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__void__void[] = { {&_swigt__p_f_p_q_const__char_p_q_const__void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__float_p_q_const__float_p_void__float[] = { {&_swigt__p_f_p_q_const__float_p_q_const__float_p_void__float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void[] = { {&_swigt__p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__void__int[] = { {&_swigt__p_f_p_q_const__void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__void__p_void[] = { {&_swigt__p_f_p_q_const__void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__void_p_q_const__void_p_void__int[] = { {&_swigt__p_f_p_q_const__void_p_q_const__void_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void__int[] = { {&_swigt__p_f_p_void_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_size_t_p_void__p_void[] = { {&_swigt__p_f_size_t_p_void__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvGraphEdge[] = { {&_swigt__p_p_CvGraphEdge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvGraphVtx[] = { {&_swigt__p_p_CvGraphVtx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvHistogram[] = { {&_swigt__p_p_CvHistogram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvMat[] = { {&_swigt__p_p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvMatND[] = { {&_swigt__p_p_CvMatND, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvPoint[] = { {&_swigt__p_p_CvPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_float_2_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvRect_t[] = {{&_swigt__p_p_CvTypedSeqT_CvRect_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvPoint_t[] = {{&_swigt__p_p_CvTypedSeqT_CvPoint_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvQuadEdge2D_t[] = {{&_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvSeq_p_t[] = {{&_swigt__p_p_CvTypedSeqT_CvSeq_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvPoint2D32f_t[] = {{&_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_float_3_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvTypedSeqT_CvConnectedComp_t[] = {{&_swigt__p_p_CvTypedSeqT_CvConnectedComp_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvSeq[] = { {&_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, _p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, _p_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvRect_t, _p_p_CvTypedSeqT_CvRect_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvPoint_t, _p_p_CvTypedSeqT_CvPoint_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t, _p_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvSeq_p_t, _p_p_CvTypedSeqT_CvSeq_p_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t, _p_p_CvTypedSeqT_CvPoint2D32f_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvSeq, 0, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, _p_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvConnectedComp_t, _p_p_CvTypedSeqT_CvConnectedComp_tTo_p_p_CvSeq, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvSeqBlock[] = { {&_swigt__p_p_CvSeqBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvSetElem[] = { {&_swigt__p_p_CvSetElem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvStereoBMState[] = { {&_swigt__p_p_CvStereoBMState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvStereoGCState[] = { {&_swigt__p_p_CvStereoGCState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_CvSubdiv2DPoint[] = { {&_swigt__p_p_CvSubdiv2DPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__CvContourScanner[] = { {&_swigt__p_p__CvContourScanner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__IplImage[] = { {&_swigt__p_p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_float[] = { {&_swigt__p_p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_CvMat[] = { {&_swigt__p_p_p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_char[] = { {&_swigt__p_p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0, 0, 0}, {&_swigt__p_CvPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_float_std__allocatorT_float_t_t[] = { {&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__PySwigIterator[] = { {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_Cv32suf,
_swigc__p_Cv64suf,
_swigc__p_CvAttrList,
_swigc__p_CvAvgComp,
_swigc__p_CvBaseImageFilter,
_swigc__p_CvBox2D,
_swigc__p_CvBoxFilter,
_swigc__p_CvChain,
_swigc__p_CvChainPtReader,
_swigc__p_CvConDensation,
_swigc__p_CvConnectedComp,
_swigc__p_CvContour,
_swigc__p_CvContourTree,
_swigc__p_CvConvexityDefect,
_swigc__p_CvFeatureTree,
_swigc__p_CvFileNode,
_swigc__p_CvFileNode_data,
_swigc__p_CvFileStorage,
_swigc__p_CvFilter,
_swigc__p_CvFont,
_swigc__p_CvGenericHash,
_swigc__p_CvGraph,
_swigc__p_CvGraphEdge,
_swigc__p_CvGraphScanner,
_swigc__p_CvGraphVtx,
_swigc__p_CvGraphVtx2D,
_swigc__p_CvHaarClassifier,
_swigc__p_CvHaarClassifierCascade,
_swigc__p_CvHaarFeature,
_swigc__p_CvHaarFeature_rect,
_swigc__p_CvHaarStageClassifier,
_swigc__p_CvHidHaarClassifierCascade,
_swigc__p_CvHistogram,
_swigc__p_CvHuMoments,
_swigc__p_CvImage,
_swigc__p_CvKalman,
_swigc__p_CvLaplaceFilter,
_swigc__p_CvLevMarq,
_swigc__p_CvLineIterator,
_swigc__p_CvLinearFilter,
_swigc__p_CvMat,
_swigc__p_CvMatND,
_swigc__p_CvMatND_data,
_swigc__p_CvMatND_dim,
_swigc__p_CvMat_data,
_swigc__p_CvMatrix,
_swigc__p_CvMatrix3,
_swigc__p_CvMemBlock,
_swigc__p_CvMemStorage,
_swigc__p_CvMemStoragePos,
_swigc__p_CvModule,
_swigc__p_CvModuleInfo,
_swigc__p_CvMoments,
_swigc__p_CvMorphology,
_swigc__p_CvNArrayIterator,
_swigc__p_CvNextEdgeType,
_swigc__p_CvPOSITObject,
_swigc__p_CvPluginFuncInfo,
_swigc__p_CvPoint,
_swigc__p_CvPoint2D32f,
_swigc__p_CvPoint2D64f,
_swigc__p_CvPoint3D32f,
_swigc__p_CvPoint3D64f,
_swigc__p_CvQuadEdge2D,
_swigc__p_CvRNG_Wrapper,
_swigc__p_CvRandState,
_swigc__p_CvRect,
_swigc__p_CvSURFParams,
_swigc__p_CvSURFPoint,
_swigc__p_CvScalar,
_swigc__p_CvSepFilter,
_swigc__p_CvSeq,
_swigc__p_CvSeqBlock,
_swigc__p_CvSeqReader,
_swigc__p_CvSeqWriter,
_swigc__p_CvSet,
_swigc__p_CvSetElem,
_swigc__p_CvSize,
_swigc__p_CvSize2D32f,
_swigc__p_CvSlice,
_swigc__p_CvSparseMat,
_swigc__p_CvSparseMatIterator,
_swigc__p_CvSparseNode,
_swigc__p_CvStereoBMState,
_swigc__p_CvStereoGCState,
_swigc__p_CvString,
_swigc__p_CvStringHashNode,
_swigc__p_CvSubdiv2D,
_swigc__p_CvSubdiv2DEdge_Wrapper,
_swigc__p_CvSubdiv2DPoint,
_swigc__p_CvSubdiv2DPointLocation,
_swigc__p_CvTermCriteria,
_swigc__p_CvTreeNodeIterator,
_swigc__p_CvTupleT_CvPoint_2_t,
_swigc__p_CvTupleT_float_2_t,
_swigc__p_CvTupleT_float_3_t,
_swigc__p_CvType,
_swigc__p_CvTypeInfo,
_swigc__p_CvTypedSeqT_CvConnectedComp_t,
_swigc__p_CvTypedSeqT_CvPoint2D32f_t,
_swigc__p_CvTypedSeqT_CvPoint_t,
_swigc__p_CvTypedSeqT_CvQuadEdge2D_t,
_swigc__p_CvTypedSeqT_CvRect_t,
_swigc__p_CvTypedSeqT_CvSeq_p_t,
_swigc__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t,
_swigc__p_CvTypedSeqT_CvTupleT_float_2_t_t,
_swigc__p_CvTypedSeqT_CvTupleT_float_3_t_t,
_swigc__p__CvContourScanner,
_swigc__p__IplConvKernel,
_swigc__p__IplConvKernelFP,
_swigc__p__IplImage,
_swigc__p__IplROI,
_swigc__p__IplTileInfo,
_swigc__p_a_2__float,
_swigc__p_a_2__signed_char,
_swigc__p_a_3__float,
_swigc__p_allocator_type,
_swigc__p_char,
_swigc__p_difference_type,
_swigc__p_double,
_swigc__p_f_int_int_int_int_int__p__IplROI,
_swigc__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage,
_swigc__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int,
_swigc__p_f_p_CvFileStorage_p_CvFileNode__p_void,
_swigc__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void,
_swigc__p_f_p__IplImage_int__void,
_swigc__p_f_p__IplImage_int_int__void,
_swigc__p_f_p_p_unsigned_char_p_unsigned_char_int_int_p_void__void,
_swigc__p_f_p_p_void__void,
_swigc__p_f_p_q_const__IplImage__p__IplImage,
_swigc__p_f_p_q_const__char_int__p_CvMat,
_swigc__p_f_p_q_const__char_int__p__IplImage,
_swigc__p_f_p_q_const__char_p_q_const__void__int,
_swigc__p_f_p_q_const__char_p_q_const__void__void,
_swigc__p_f_p_q_const__float_p_q_const__float_p_void__float,
_swigc__p_f_p_q_const__unsigned_char_p_unsigned_char_p_void__void,
_swigc__p_f_p_q_const__void__int,
_swigc__p_f_p_q_const__void__p_void,
_swigc__p_f_p_q_const__void_p_q_const__void_p_void__int,
_swigc__p_f_p_void_p_void__int,
_swigc__p_f_size_t_p_void__p_void,
_swigc__p_float,
_swigc__p_int,
_swigc__p_long_long,
_swigc__p_p_CvGraphEdge,
_swigc__p_p_CvGraphVtx,
_swigc__p_p_CvHistogram,
_swigc__p_p_CvMat,
_swigc__p_p_CvMatND,
_swigc__p_p_CvPoint,
_swigc__p_p_CvSeq,
_swigc__p_p_CvSeqBlock,
_swigc__p_p_CvSetElem,
_swigc__p_p_CvStereoBMState,
_swigc__p_p_CvStereoGCState,
_swigc__p_p_CvSubdiv2DPoint,
_swigc__p_p_CvTypedSeqT_CvConnectedComp_t,
_swigc__p_p_CvTypedSeqT_CvPoint2D32f_t,
_swigc__p_p_CvTypedSeqT_CvPoint_t,
_swigc__p_p_CvTypedSeqT_CvQuadEdge2D_t,
_swigc__p_p_CvTypedSeqT_CvRect_t,
_swigc__p_p_CvTypedSeqT_CvSeq_p_t,
_swigc__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t,
_swigc__p_p_CvTypedSeqT_CvTupleT_float_2_t_t,
_swigc__p_p_CvTypedSeqT_CvTupleT_float_3_t_t,
_swigc__p_p_PyObject,
_swigc__p_p__CvContourScanner,
_swigc__p_p__IplImage,
_swigc__p_p_char,
_swigc__p_p_double,
_swigc__p_p_float,
_swigc__p_p_p_CvMat,
_swigc__p_p_unsigned_char,
_swigc__p_p_void,
_swigc__p_short,
_swigc__p_signed_char,
_swigc__p_size_t,
_swigc__p_size_type,
_swigc__p_std__invalid_argument,
_swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t,
_swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type,
_swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type,
_swigc__p_std__vectorT_float_std__allocatorT_float_t_t,
_swigc__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type,
_swigc__p_swig__PySwigIterator,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
_swigc__p_value_type,
_swigc__p_void,
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Type initialization:
* This problem is tough by the requirement that no dynamic
* memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
* to swig_type_info structures, we need some lookup code at initialization.
* The idea is that swig generates all the structures that are needed.
* The runtime then collects these partially filled structures.
* The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
* The generated swig_type_info structures are assigned staticly to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
* cast linked list. The cast data is initially stored in something like a
* two-dimensional array. Each row corresponds to a type (there are the same
* number of rows as there are in the swig_type_initial array). Each entry in
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
* we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
* First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
* 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
* swig_cast_info to the linked list (because the cast->type) pointer will
* be correct.
* ----------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif
#if 0
#define SWIGRUNTIME_DEBUG
#endif
SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
int found, init;
clientdata = clientdata;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
/* Initialize the swig_module */
swig_module.type_initial = swig_type_initial;
swig_module.cast_initial = swig_cast_initial;
swig_module.next = &swig_module;
init = 1;
} else {
init = 0;
}
/* Try and load any already created modules */
module_head = SWIG_GetModule(clientdata);
if (!module_head) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
module_head = &swig_module;
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
found=0;
iter=module_head;
do {
if (iter==&swig_module) {
found=1;
break;
}
iter=iter->next;
} while (iter!= module_head);
/* if the is found in the list, then all is done and we may leave */
if (found) return;
/* otherwise we must add out module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
/* When multiple interpeters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
if (init == 0) return;
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
if (swig_module.next != &swig_module) {
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
}
if (type) {
/* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
if (swig_module.type_initial[i]->clientdata) {
type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
}
} else {
type = swig_module.type_initial[i];
}
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
if (swig_module.next != &swig_module) {
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
}
if (ret) {
if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
cast->type = ret;
ret = 0;
} else {
/* Check for casting already in the list */
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
if (!ocast) ret = 0;
}
}
if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
if (type->cast) {
type->cast->prev = cast;
cast->next = type->cast;
}
type->cast = cast;
}
cast++;
}
/* Set entry in modules->types array equal to the type */
swig_module.types[i] = type;
}
swig_module.types[i] = 0;
#ifdef SWIGRUNTIME_DEBUG
printf("**** SWIG_InitializeModule: Cast List ******\n");
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
++j;
}
printf("---- Total casts: %d\n",j);
}
printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}
/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types. It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
size_t i;
swig_cast_info *equiv;
static int init_run = 0;
if (init_run) return;
init_run = 1;
for (i = 0; i < swig_module.size; i++) {
if (swig_module.types[i]->clientdata) {
equiv = swig_module.types[i]->cast;
while (equiv) {
if (!equiv->converter) {
if (equiv->type && !equiv->type->clientdata)
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
}
equiv = equiv->next;
}
}
}
}
#ifdef __cplusplus
#if 0
{
/* c-mode */
#endif
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
return PyString_FromString("<Swig global variables>");
}
SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject *v) {
PyObject *str = PyString_FromString("(");
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
return str;
}
SWIGINTERN int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
PyObject *str = swig_varlink_str(v);
fprintf(fp,"Swig global variables ");
fprintf(fp,"%s\n", PyString_AsString(str));
Py_DECREF(str);
return 0;
}
SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject *v) {
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
}
return res;
}
SWIGINTERN int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
}
return res;
}
SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp
= {
PyObject_HEAD_INIT(NULL)
0, /* Number of items in variable part (ob_size) */
(char *)"swigvarlink", /* Type name (tp_name) */
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
0, /* Itemsize (tp_itemsize) */
(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
(printfunc) swig_varlink_print, /* Print (tp_print) */
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc)swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
varlink__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
#endif
#ifdef COUNT_ALLOCS
0,0,0,0 /* tp_alloc -> tp_next */
#endif
};
varlink_type = tmp;
varlink_type.ob_type = &PyType_Type;
type_init = 1;
}
return &varlink_type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
strncpy(gv->name,name,size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
SWIGINTERN PyObject *
SWIG_globals(void) {
static PyObject *_SWIG_globals = 0;
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
return _SWIG_globals;
}
/* -----------------------------------------------------------------------------
* constants/methods manipulation
* ----------------------------------------------------------------------------- */
/* Install Constants */
SWIGINTERN void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
PyObject *obj = 0;
size_t i;
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
break;
default:
obj = 0;
break;
}
if (obj) {
PyDict_SetItemString(d, constants[i].name, obj);
Py_DECREF(obj);
}
}
}
/* -----------------------------------------------------------------------------*/
/* Fix SwigMethods to carry the callback ptrs when needed */
/* -----------------------------------------------------------------------------*/
SWIGINTERN void
SWIG_Python_FixMethods(PyMethodDef *methods,
swig_const_info *const_table,
swig_type_info **types,
swig_type_info **types_initial) {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = (char*)methods[i].ml_doc;
if (c && (c = strstr(c, "swig_ptr: "))) {
int j;
swig_const_info *ci = 0;
const char *name = c + 10;
for (j = 0; const_table[j].type; ++j) {
if (strncmp(const_table[j].name, name,
strlen(const_table[j].name)) == 0) {
ci = &(const_table[j]);
break;
}
}
if (ci) {
size_t shift = (ci->ptype) - types;
swig_type_info *ty = types_initial[shift];
size_t ldoc = (c - methods[i].ml_doc);
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
char *ndoc = (char*)malloc(ldoc + lptr + 10);
if (ndoc) {
char *buff = ndoc;
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
if (ptr) {
strncpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
strncpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
}
}
}
}
}
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------*
* Partial Init method
* -----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIG_init(void) {
PyObject *m, *d;
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
m = Py_InitModule((char *) SWIG_name, SwigMethods);
d = PyModule_GetDict(m);
SWIG_InitializeModule(0);
SWIG_InstallConstants(d,swig_const_table);
SWIG_Python_SetConstant(d, "sizeof_CvContour",SWIG_From_size_t(static_cast< size_t >(sizeof(CvContour))));
SWIG_Python_SetConstant(d, "sizeof_CvPoint",SWIG_From_size_t(static_cast< size_t >(sizeof(CvPoint))));
SWIG_Python_SetConstant(d, "sizeof_CvSeq",SWIG_From_size_t(static_cast< size_t >(sizeof(CvSeq))));
PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
SWIG_addvarlink(SWIG_globals(),(char*)"icvDepthToType",Swig_var_icvDepthToType_get, Swig_var_icvDepthToType_set);
SWIG_Python_SetConstant(d, "CV_AUTOSTEP",SWIG_From_int(static_cast< int >(0x7fffffff)));
SWIG_Python_SetConstant(d, "CV_MAX_ARR",SWIG_From_int(static_cast< int >(10)));
SWIG_Python_SetConstant(d, "CV_NO_DEPTH_CHECK",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_NO_CN_CHECK",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_NO_SIZE_CHECK",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_CMP_EQ",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_CMP_GT",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CMP_GE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_CMP_LT",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_CMP_LE",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_CMP_NE",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_CHECK_RANGE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CHECK_QUIET",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_RAND_UNI",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_RAND_NORMAL",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SORT_EVERY_ROW",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SORT_EVERY_COLUMN",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SORT_ASCENDING",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SORT_DESCENDING",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_GEMM_A_T",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_GEMM_B_T",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_GEMM_C_T",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_SVD_MODIFY_A",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SVD_U_T",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_SVD_V_T",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_LU",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SVD",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SVD_SYM",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_LSQ",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_COVAR_SCRAMBLED",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_COVAR_NORMAL",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_COVAR_USE_AVG",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_COVAR_SCALE",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_COVAR_ROWS",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_COVAR_COLS",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_PCA_DATA_AS_ROW",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_PCA_DATA_AS_COL",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_PCA_USE_AVG",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_C",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_L1",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_L2",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_NORM_MASK",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_RELATIVE",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_DIFF",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_MINMAX",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_DIFF_C",SWIG_From_int(static_cast< int >((16|1))));
SWIG_Python_SetConstant(d, "CV_DIFF_L1",SWIG_From_int(static_cast< int >((16|2))));
SWIG_Python_SetConstant(d, "CV_DIFF_L2",SWIG_From_int(static_cast< int >((16|4))));
SWIG_Python_SetConstant(d, "CV_RELATIVE_C",SWIG_From_int(static_cast< int >((8|1))));
SWIG_Python_SetConstant(d, "CV_RELATIVE_L1",SWIG_From_int(static_cast< int >((8|2))));
SWIG_Python_SetConstant(d, "CV_RELATIVE_L2",SWIG_From_int(static_cast< int >((8|4))));
SWIG_Python_SetConstant(d, "CV_REDUCE_SUM",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_REDUCE_AVG",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_REDUCE_MAX",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_REDUCE_MIN",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_DXT_FORWARD",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_DXT_INVERSE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_DXT_SCALE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_DXT_INV_SCALE",SWIG_From_int(static_cast< int >((1+2))));
SWIG_Python_SetConstant(d, "CV_DXT_INVERSE_SCALE",SWIG_From_int(static_cast< int >((1+2))));
SWIG_Python_SetConstant(d, "CV_DXT_ROWS",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_DXT_MUL_CONJ",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_FRONT",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_BACK",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_GRAPH_VERTEX",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_GRAPH_TREE_EDGE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_GRAPH_BACK_EDGE",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_GRAPH_FORWARD_EDGE",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_GRAPH_CROSS_EDGE",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_GRAPH_ANY_EDGE",SWIG_From_int(static_cast< int >(30)));
SWIG_Python_SetConstant(d, "CV_GRAPH_NEW_TREE",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_GRAPH_BACKTRACKING",SWIG_From_int(static_cast< int >(64)));
SWIG_Python_SetConstant(d, "CV_GRAPH_OVER",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_GRAPH_ALL_ITEMS",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_GRAPH_ITEM_VISITED_FLAG",SWIG_From_int(static_cast< int >((1 << 30))));
SWIG_Python_SetConstant(d, "CV_GRAPH_SEARCH_TREE_NODE_FLAG",SWIG_From_int(static_cast< int >((1 << 29))));
SWIG_Python_SetConstant(d, "CV_GRAPH_FORWARD_EDGE_FLAG",SWIG_From_int(static_cast< int >((1 << 28))));
SWIG_Python_SetConstant(d, "CV_FILLED",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_AA",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_SIMPLEX",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_PLAIN",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_DUPLEX",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_COMPLEX",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_TRIPLEX",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_COMPLEX_SMALL",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_SCRIPT_SIMPLEX",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_FONT_HERSHEY_SCRIPT_COMPLEX",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_FONT_ITALIC",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_FONT_VECTOR0",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_ErrModeLeaf",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_ErrModeParent",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_ErrModeSilent",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_MAJOR_VERSION",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_MINOR_VERSION",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SUBMINOR_VERSION",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_VERSION",SWIG_FromCharPtr("1.1.0"));
SWIG_Python_SetConstant(d, "CV_PI",SWIG_From_double(static_cast< double >(3.1415926535897932384626433832795)));
SWIG_Python_SetConstant(d, "CV_LOG2",SWIG_From_double(static_cast< double >(0.69314718055994530941723212145818)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_SIGN",SWIG_From_int(static_cast< int >(0x80000000)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_1U",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_8U",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_16U",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_32F",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "IPL_DEPTH_8S",SWIG_From_int(static_cast< int >((0x80000000|8))));
SWIG_Python_SetConstant(d, "IPL_DEPTH_16S",SWIG_From_int(static_cast< int >((0x80000000|16))));
SWIG_Python_SetConstant(d, "IPL_DEPTH_32S",SWIG_From_int(static_cast< int >((0x80000000|32))));
SWIG_Python_SetConstant(d, "IPL_DATA_ORDER_PIXEL",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "IPL_DATA_ORDER_PLANE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "IPL_ORIGIN_TL",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "IPL_ORIGIN_BL",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_4BYTES",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_8BYTES",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_16BYTES",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_32BYTES",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_DWORD",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "IPL_ALIGN_QWORD",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "IPL_BORDER_CONSTANT",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "IPL_BORDER_REPLICATE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "IPL_BORDER_REFLECT",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "IPL_BORDER_WRAP",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "IPL_IMAGE_HEADER",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "IPL_IMAGE_DATA",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "IPL_IMAGE_ROI",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "IPL_BORDER_REFLECT_101",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_IMAGE",SWIG_FromCharPtr("opencv-image"));
SWIG_Python_SetConstant(d, "IPL_DEPTH_64F",SWIG_From_int(static_cast< int >(64)));
SWIG_Python_SetConstant(d, "CV_CN_MAX",SWIG_From_int(static_cast< int >(64)));
SWIG_Python_SetConstant(d, "CV_CN_SHIFT",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_DEPTH_MAX",SWIG_From_int(static_cast< int >((1 << 3))));
SWIG_Python_SetConstant(d, "CV_8U",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_8S",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_16U",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_16S",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_32S",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_32F",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_64F",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_USRTYPE1",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_8UC1",SWIG_From_int(static_cast< int >(((0) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8UC2",SWIG_From_int(static_cast< int >(((0) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8UC3",SWIG_From_int(static_cast< int >(((0) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8UC4",SWIG_From_int(static_cast< int >(((0) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8SC1",SWIG_From_int(static_cast< int >(((1) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8SC2",SWIG_From_int(static_cast< int >(((1) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8SC3",SWIG_From_int(static_cast< int >(((1) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_8SC4",SWIG_From_int(static_cast< int >(((1) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16UC1",SWIG_From_int(static_cast< int >(((2) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16UC2",SWIG_From_int(static_cast< int >(((2) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16UC3",SWIG_From_int(static_cast< int >(((2) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16UC4",SWIG_From_int(static_cast< int >(((2) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16SC1",SWIG_From_int(static_cast< int >(((3) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16SC2",SWIG_From_int(static_cast< int >(((3) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16SC3",SWIG_From_int(static_cast< int >(((3) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_16SC4",SWIG_From_int(static_cast< int >(((3) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32SC1",SWIG_From_int(static_cast< int >(((4) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32SC2",SWIG_From_int(static_cast< int >(((4) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32SC3",SWIG_From_int(static_cast< int >(((4) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32SC4",SWIG_From_int(static_cast< int >(((4) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32FC1",SWIG_From_int(static_cast< int >(((5) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32FC2",SWIG_From_int(static_cast< int >(((5) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32FC3",SWIG_From_int(static_cast< int >(((5) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_32FC4",SWIG_From_int(static_cast< int >(((5) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_64FC1",SWIG_From_int(static_cast< int >(((6) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_64FC2",SWIG_From_int(static_cast< int >(((6) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_64FC3",SWIG_From_int(static_cast< int >(((6) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_64FC4",SWIG_From_int(static_cast< int >(((6) +(((4) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_AUTO_STEP",SWIG_From_int(static_cast< int >(0x7fffffff)));
SWIG_Python_SetConstant(d, "CV_MAT_CN_MASK",SWIG_From_int(static_cast< int >(((64-1) << 3))));
SWIG_Python_SetConstant(d, "CV_MAT_DEPTH_MASK",SWIG_From_int(static_cast< int >(((1 << 3) -1))));
SWIG_Python_SetConstant(d, "CV_MAT_TYPE_MASK",SWIG_From_int(static_cast< int >(((1 << 3) *64-1))));
SWIG_Python_SetConstant(d, "CV_MAT_CONT_FLAG_SHIFT",SWIG_From_int(static_cast< int >(14)));
SWIG_Python_SetConstant(d, "CV_MAT_CONT_FLAG",SWIG_From_int(static_cast< int >((1 << 14))));
SWIG_Python_SetConstant(d, "CV_MAT_TEMP_FLAG_SHIFT",SWIG_From_int(static_cast< int >(15)));
SWIG_Python_SetConstant(d, "CV_MAT_TEMP_FLAG",SWIG_From_int(static_cast< int >((1 << 15))));
SWIG_Python_SetConstant(d, "CV_MAGIC_MASK",SWIG_From_int(static_cast< int >(0xFFFF0000)));
SWIG_Python_SetConstant(d, "CV_MAT_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42420000)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_MAT",SWIG_FromCharPtr("opencv-matrix"));
SWIG_Python_SetConstant(d, "CV_MATND_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42430000)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_MATND",SWIG_FromCharPtr("opencv-nd-matrix"));
SWIG_Python_SetConstant(d, "CV_MAX_DIM",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_MAX_DIM_HEAP",SWIG_From_int(static_cast< int >((1 << 16))));
SWIG_Python_SetConstant(d, "CV_SPARSE_MAT_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42440000)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_SPARSE_MAT",SWIG_FromCharPtr("opencv-sparse-matrix"));
SWIG_Python_SetConstant(d, "CV_HIST_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42450000)));
SWIG_Python_SetConstant(d, "CV_HIST_UNIFORM_FLAG",SWIG_From_int(static_cast< int >((1 << 10))));
SWIG_Python_SetConstant(d, "CV_HIST_RANGES_FLAG",SWIG_From_int(static_cast< int >((1 << 11))));
SWIG_Python_SetConstant(d, "CV_HIST_ARRAY",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_HIST_SPARSE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_HIST_TREE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_HIST_UNIFORM",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_TERMCRIT_ITER",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_TERMCRIT_NUMBER",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_TERMCRIT_EPS",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_WHOLE_SEQ_END_INDEX",SWIG_From_int(static_cast< int >(0x3fffffff)));
SWIG_Python_SetConstant(d, "CV_STORAGE_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42890000)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_SEQ",SWIG_FromCharPtr("opencv-sequence"));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_SEQ_TREE",SWIG_FromCharPtr("opencv-sequence-tree"));
SWIG_Python_SetConstant(d, "CV_SET_ELEM_IDX_MASK",SWIG_From_int(static_cast< int >(((1 << 26) -1))));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_GRAPH",SWIG_FromCharPtr("opencv-graph"));
SWIG_Python_SetConstant(d, "CV_SEQ_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42990000)));
SWIG_Python_SetConstant(d, "CV_SET_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42980000)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_BITS",SWIG_From_int(static_cast< int >(9)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_MASK",SWIG_From_int(static_cast< int >(((1 << 9) -1))));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_POINT",SWIG_From_int(static_cast< int >(((4) +(((2) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_CODE",SWIG_From_int(static_cast< int >(((0) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_GENERIC",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_PTR",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_PPOINT",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_INDEX",SWIG_From_int(static_cast< int >(((4) +(((1) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_GRAPH_EDGE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_GRAPH_VERTEX",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_TRIAN_ATR",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_CONNECTED_COMP",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SEQ_ELTYPE_POINT3D",SWIG_From_int(static_cast< int >(((5) +(((3) -1) << 3)))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_BITS",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_MASK",SWIG_From_int(static_cast< int >((((1 << 3) -1) << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_GENERIC",SWIG_From_int(static_cast< int >((0 << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_CURVE",SWIG_From_int(static_cast< int >((1 << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_BIN_TREE",SWIG_From_int(static_cast< int >((2 << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_GRAPH",SWIG_From_int(static_cast< int >((3 << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_KIND_SUBDIV2D",SWIG_From_int(static_cast< int >((4 << 9))));
SWIG_Python_SetConstant(d, "CV_SEQ_FLAG_SHIFT",SWIG_From_int(static_cast< int >((3+9))));
SWIG_Python_SetConstant(d, "CV_SEQ_FLAG_CLOSED",SWIG_From_int(static_cast< int >((1 << (3+9)))));
SWIG_Python_SetConstant(d, "CV_SEQ_FLAG_SIMPLE",SWIG_From_int(static_cast< int >((2 << (3+9)))));
SWIG_Python_SetConstant(d, "CV_SEQ_FLAG_CONVEX",SWIG_From_int(static_cast< int >((4 << (3+9)))));
SWIG_Python_SetConstant(d, "CV_SEQ_FLAG_HOLE",SWIG_From_int(static_cast< int >((8 << (3+9)))));
SWIG_Python_SetConstant(d, "CV_GRAPH_FLAG_ORIENTED",SWIG_From_int(static_cast< int >((1 << (3+9)))));
SWIG_Python_SetConstant(d, "CV_GRAPH",SWIG_From_int(static_cast< int >((3 << 9))));
SWIG_Python_SetConstant(d, "CV_ORIENTED_GRAPH",SWIG_From_int(static_cast< int >(((3 << 9)|(1 << (3+9))))));
SWIG_Python_SetConstant(d, "CV_SEQ_POINT_SET",SWIG_From_int(static_cast< int >(((0 << 9)|((4) +(((2) -1) << 3))))));
SWIG_Python_SetConstant(d, "CV_SEQ_POINT3D_SET",SWIG_From_int(static_cast< int >(((0 << 9)|((5) +(((3) -1) << 3))))));
SWIG_Python_SetConstant(d, "CV_SEQ_POLYLINE",SWIG_From_int(static_cast< int >(((1 << 9)|((4) +(((2) -1) << 3))))));
SWIG_Python_SetConstant(d, "CV_SEQ_POLYGON",SWIG_From_int(static_cast< int >(((1 << (3+9))|((1 << 9)|((4) +(((2) -1) << 3)))))));
SWIG_Python_SetConstant(d, "CV_SEQ_CONTOUR",SWIG_From_int(static_cast< int >(((1 << (3+9))|((1 << 9)|((4) +(((2) -1) << 3)))))));
SWIG_Python_SetConstant(d, "CV_SEQ_SIMPLE_POLYGON",SWIG_From_int(static_cast< int >(((2 << (3+9))|((1 << (3+9))|((1 << 9)|((4) +(((2) -1) << 3))))))));
SWIG_Python_SetConstant(d, "CV_SEQ_CHAIN",SWIG_From_int(static_cast< int >(((1 << 9)|((0) +(((1) -1) << 3))))));
SWIG_Python_SetConstant(d, "CV_SEQ_CHAIN_CONTOUR",SWIG_From_int(static_cast< int >(((1 << (3+9))|((1 << 9)|((0) +(((1) -1) << 3)))))));
SWIG_Python_SetConstant(d, "CV_SEQ_POLYGON_TREE",SWIG_From_int(static_cast< int >(((2 << 9)|0))));
SWIG_Python_SetConstant(d, "CV_SEQ_CONNECTED_COMP",SWIG_From_int(static_cast< int >(((0 << 9)|0))));
SWIG_Python_SetConstant(d, "CV_SEQ_INDEX",SWIG_From_int(static_cast< int >(((0 << 9)|((4) +(((1) -1) << 3))))));
SWIG_Python_SetConstant(d, "CV_STORAGE_READ",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_STORAGE_WRITE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_STORAGE_WRITE_TEXT",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_STORAGE_WRITE_BINARY",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_STORAGE_APPEND",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_NODE_NONE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_NODE_INT",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_NODE_INTEGER",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_NODE_REAL",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_NODE_FLOAT",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_NODE_STR",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_NODE_STRING",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_NODE_REF",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_NODE_SEQ",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_NODE_MAP",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_NODE_TYPE_MASK",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_NODE_FLOW",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_NODE_USER",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_NODE_EMPTY",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_NODE_NAMED",SWIG_From_int(static_cast< int >(64)));
SWIG_Python_SetConstant(d, "CV_NODE_SEQ_SIMPLE",SWIG_From_int(static_cast< int >(256)));
SWIG_Python_SetConstant(d, "CV_StsOk",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_StsBackTrace",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_StsError",SWIG_From_int(static_cast< int >(-2)));
SWIG_Python_SetConstant(d, "CV_StsInternal",SWIG_From_int(static_cast< int >(-3)));
SWIG_Python_SetConstant(d, "CV_StsNoMem",SWIG_From_int(static_cast< int >(-4)));
SWIG_Python_SetConstant(d, "CV_StsBadArg",SWIG_From_int(static_cast< int >(-5)));
SWIG_Python_SetConstant(d, "CV_StsBadFunc",SWIG_From_int(static_cast< int >(-6)));
SWIG_Python_SetConstant(d, "CV_StsNoConv",SWIG_From_int(static_cast< int >(-7)));
SWIG_Python_SetConstant(d, "CV_StsAutoTrace",SWIG_From_int(static_cast< int >(-8)));
SWIG_Python_SetConstant(d, "CV_HeaderIsNull",SWIG_From_int(static_cast< int >(-9)));
SWIG_Python_SetConstant(d, "CV_BadImageSize",SWIG_From_int(static_cast< int >(-10)));
SWIG_Python_SetConstant(d, "CV_BadOffset",SWIG_From_int(static_cast< int >(-11)));
SWIG_Python_SetConstant(d, "CV_BadDataPtr",SWIG_From_int(static_cast< int >(-12)));
SWIG_Python_SetConstant(d, "CV_BadStep",SWIG_From_int(static_cast< int >(-13)));
SWIG_Python_SetConstant(d, "CV_BadModelOrChSeq",SWIG_From_int(static_cast< int >(-14)));
SWIG_Python_SetConstant(d, "CV_BadNumChannels",SWIG_From_int(static_cast< int >(-15)));
SWIG_Python_SetConstant(d, "CV_BadNumChannel1U",SWIG_From_int(static_cast< int >(-16)));
SWIG_Python_SetConstant(d, "CV_BadDepth",SWIG_From_int(static_cast< int >(-17)));
SWIG_Python_SetConstant(d, "CV_BadAlphaChannel",SWIG_From_int(static_cast< int >(-18)));
SWIG_Python_SetConstant(d, "CV_BadOrder",SWIG_From_int(static_cast< int >(-19)));
SWIG_Python_SetConstant(d, "CV_BadOrigin",SWIG_From_int(static_cast< int >(-20)));
SWIG_Python_SetConstant(d, "CV_BadAlign",SWIG_From_int(static_cast< int >(-21)));
SWIG_Python_SetConstant(d, "CV_BadCallBack",SWIG_From_int(static_cast< int >(-22)));
SWIG_Python_SetConstant(d, "CV_BadTileSize",SWIG_From_int(static_cast< int >(-23)));
SWIG_Python_SetConstant(d, "CV_BadCOI",SWIG_From_int(static_cast< int >(-24)));
SWIG_Python_SetConstant(d, "CV_BadROISize",SWIG_From_int(static_cast< int >(-25)));
SWIG_Python_SetConstant(d, "CV_MaskIsTiled",SWIG_From_int(static_cast< int >(-26)));
SWIG_Python_SetConstant(d, "CV_StsNullPtr",SWIG_From_int(static_cast< int >(-27)));
SWIG_Python_SetConstant(d, "CV_StsVecLengthErr",SWIG_From_int(static_cast< int >(-28)));
SWIG_Python_SetConstant(d, "CV_StsFilterStructContentErr",SWIG_From_int(static_cast< int >(-29)));
SWIG_Python_SetConstant(d, "CV_StsKernelStructContentErr",SWIG_From_int(static_cast< int >(-30)));
SWIG_Python_SetConstant(d, "CV_StsFilterOffsetErr",SWIG_From_int(static_cast< int >(-31)));
SWIG_Python_SetConstant(d, "CV_StsBadSize",SWIG_From_int(static_cast< int >(-201)));
SWIG_Python_SetConstant(d, "CV_StsDivByZero",SWIG_From_int(static_cast< int >(-202)));
SWIG_Python_SetConstant(d, "CV_StsInplaceNotSupported",SWIG_From_int(static_cast< int >(-203)));
SWIG_Python_SetConstant(d, "CV_StsObjectNotFound",SWIG_From_int(static_cast< int >(-204)));
SWIG_Python_SetConstant(d, "CV_StsUnmatchedFormats",SWIG_From_int(static_cast< int >(-205)));
SWIG_Python_SetConstant(d, "CV_StsBadFlag",SWIG_From_int(static_cast< int >(-206)));
SWIG_Python_SetConstant(d, "CV_StsBadPoint",SWIG_From_int(static_cast< int >(-207)));
SWIG_Python_SetConstant(d, "CV_StsBadMask",SWIG_From_int(static_cast< int >(-208)));
SWIG_Python_SetConstant(d, "CV_StsUnmatchedSizes",SWIG_From_int(static_cast< int >(-209)));
SWIG_Python_SetConstant(d, "CV_StsUnsupportedFormat",SWIG_From_int(static_cast< int >(-210)));
SWIG_Python_SetConstant(d, "CV_StsOutOfRange",SWIG_From_int(static_cast< int >(-211)));
SWIG_Python_SetConstant(d, "CV_StsParseError",SWIG_From_int(static_cast< int >(-212)));
SWIG_Python_SetConstant(d, "CV_StsNotImplemented",SWIG_From_int(static_cast< int >(-213)));
SWIG_Python_SetConstant(d, "CV_StsBadMemBlock",SWIG_From_int(static_cast< int >(-214)));
SWIG_Python_SetConstant(d, "CV_BLUR_NO_SCALE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_BLUR",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_GAUSSIAN",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_MEDIAN",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_BILATERAL",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_INPAINT_NS",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_INPAINT_TELEA",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SCHARR",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_MAX_SOBEL_KSIZE",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_BGR2BGRA",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_RGB2RGBA",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_BGRA2BGR",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_RGBA2RGB",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_BGR2RGBA",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_RGB2BGRA",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_RGBA2BGR",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_BGRA2RGB",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_BGR2RGB",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_RGB2BGR",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_BGRA2RGBA",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_RGBA2BGRA",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_BGR2GRAY",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_RGB2GRAY",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_GRAY2BGR",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_GRAY2RGB",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_GRAY2BGRA",SWIG_From_int(static_cast< int >(9)));
SWIG_Python_SetConstant(d, "CV_GRAY2RGBA",SWIG_From_int(static_cast< int >(9)));
SWIG_Python_SetConstant(d, "CV_BGRA2GRAY",SWIG_From_int(static_cast< int >(10)));
SWIG_Python_SetConstant(d, "CV_RGBA2GRAY",SWIG_From_int(static_cast< int >(11)));
SWIG_Python_SetConstant(d, "CV_BGR2BGR565",SWIG_From_int(static_cast< int >(12)));
SWIG_Python_SetConstant(d, "CV_RGB2BGR565",SWIG_From_int(static_cast< int >(13)));
SWIG_Python_SetConstant(d, "CV_BGR5652BGR",SWIG_From_int(static_cast< int >(14)));
SWIG_Python_SetConstant(d, "CV_BGR5652RGB",SWIG_From_int(static_cast< int >(15)));
SWIG_Python_SetConstant(d, "CV_BGRA2BGR565",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_RGBA2BGR565",SWIG_From_int(static_cast< int >(17)));
SWIG_Python_SetConstant(d, "CV_BGR5652BGRA",SWIG_From_int(static_cast< int >(18)));
SWIG_Python_SetConstant(d, "CV_BGR5652RGBA",SWIG_From_int(static_cast< int >(19)));
SWIG_Python_SetConstant(d, "CV_GRAY2BGR565",SWIG_From_int(static_cast< int >(20)));
SWIG_Python_SetConstant(d, "CV_BGR5652GRAY",SWIG_From_int(static_cast< int >(21)));
SWIG_Python_SetConstant(d, "CV_BGR2BGR555",SWIG_From_int(static_cast< int >(22)));
SWIG_Python_SetConstant(d, "CV_RGB2BGR555",SWIG_From_int(static_cast< int >(23)));
SWIG_Python_SetConstant(d, "CV_BGR5552BGR",SWIG_From_int(static_cast< int >(24)));
SWIG_Python_SetConstant(d, "CV_BGR5552RGB",SWIG_From_int(static_cast< int >(25)));
SWIG_Python_SetConstant(d, "CV_BGRA2BGR555",SWIG_From_int(static_cast< int >(26)));
SWIG_Python_SetConstant(d, "CV_RGBA2BGR555",SWIG_From_int(static_cast< int >(27)));
SWIG_Python_SetConstant(d, "CV_BGR5552BGRA",SWIG_From_int(static_cast< int >(28)));
SWIG_Python_SetConstant(d, "CV_BGR5552RGBA",SWIG_From_int(static_cast< int >(29)));
SWIG_Python_SetConstant(d, "CV_GRAY2BGR555",SWIG_From_int(static_cast< int >(30)));
SWIG_Python_SetConstant(d, "CV_BGR5552GRAY",SWIG_From_int(static_cast< int >(31)));
SWIG_Python_SetConstant(d, "CV_BGR2XYZ",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_RGB2XYZ",SWIG_From_int(static_cast< int >(33)));
SWIG_Python_SetConstant(d, "CV_XYZ2BGR",SWIG_From_int(static_cast< int >(34)));
SWIG_Python_SetConstant(d, "CV_XYZ2RGB",SWIG_From_int(static_cast< int >(35)));
SWIG_Python_SetConstant(d, "CV_BGR2YCrCb",SWIG_From_int(static_cast< int >(36)));
SWIG_Python_SetConstant(d, "CV_RGB2YCrCb",SWIG_From_int(static_cast< int >(37)));
SWIG_Python_SetConstant(d, "CV_YCrCb2BGR",SWIG_From_int(static_cast< int >(38)));
SWIG_Python_SetConstant(d, "CV_YCrCb2RGB",SWIG_From_int(static_cast< int >(39)));
SWIG_Python_SetConstant(d, "CV_BGR2HSV",SWIG_From_int(static_cast< int >(40)));
SWIG_Python_SetConstant(d, "CV_RGB2HSV",SWIG_From_int(static_cast< int >(41)));
SWIG_Python_SetConstant(d, "CV_BGR2Lab",SWIG_From_int(static_cast< int >(44)));
SWIG_Python_SetConstant(d, "CV_RGB2Lab",SWIG_From_int(static_cast< int >(45)));
SWIG_Python_SetConstant(d, "CV_BayerBG2BGR",SWIG_From_int(static_cast< int >(46)));
SWIG_Python_SetConstant(d, "CV_BayerGB2BGR",SWIG_From_int(static_cast< int >(47)));
SWIG_Python_SetConstant(d, "CV_BayerRG2BGR",SWIG_From_int(static_cast< int >(48)));
SWIG_Python_SetConstant(d, "CV_BayerGR2BGR",SWIG_From_int(static_cast< int >(49)));
SWIG_Python_SetConstant(d, "CV_BayerBG2RGB",SWIG_From_int(static_cast< int >(48)));
SWIG_Python_SetConstant(d, "CV_BayerGB2RGB",SWIG_From_int(static_cast< int >(49)));
SWIG_Python_SetConstant(d, "CV_BayerRG2RGB",SWIG_From_int(static_cast< int >(46)));
SWIG_Python_SetConstant(d, "CV_BayerGR2RGB",SWIG_From_int(static_cast< int >(47)));
SWIG_Python_SetConstant(d, "CV_BGR2Luv",SWIG_From_int(static_cast< int >(50)));
SWIG_Python_SetConstant(d, "CV_RGB2Luv",SWIG_From_int(static_cast< int >(51)));
SWIG_Python_SetConstant(d, "CV_BGR2HLS",SWIG_From_int(static_cast< int >(52)));
SWIG_Python_SetConstant(d, "CV_RGB2HLS",SWIG_From_int(static_cast< int >(53)));
SWIG_Python_SetConstant(d, "CV_HSV2BGR",SWIG_From_int(static_cast< int >(54)));
SWIG_Python_SetConstant(d, "CV_HSV2RGB",SWIG_From_int(static_cast< int >(55)));
SWIG_Python_SetConstant(d, "CV_Lab2BGR",SWIG_From_int(static_cast< int >(56)));
SWIG_Python_SetConstant(d, "CV_Lab2RGB",SWIG_From_int(static_cast< int >(57)));
SWIG_Python_SetConstant(d, "CV_Luv2BGR",SWIG_From_int(static_cast< int >(58)));
SWIG_Python_SetConstant(d, "CV_Luv2RGB",SWIG_From_int(static_cast< int >(59)));
SWIG_Python_SetConstant(d, "CV_HLS2BGR",SWIG_From_int(static_cast< int >(60)));
SWIG_Python_SetConstant(d, "CV_HLS2RGB",SWIG_From_int(static_cast< int >(61)));
SWIG_Python_SetConstant(d, "CV_COLORCVT_MAX",SWIG_From_int(static_cast< int >(100)));
SWIG_Python_SetConstant(d, "CV_INTER_NN",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_INTER_LINEAR",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_INTER_CUBIC",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_INTER_AREA",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_WARP_FILL_OUTLIERS",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_WARP_INVERSE_MAP",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_SHAPE_RECT",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_SHAPE_CROSS",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_SHAPE_ELLIPSE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_SHAPE_CUSTOM",SWIG_From_int(static_cast< int >(100)));
SWIG_Python_SetConstant(d, "CV_MOP_OPEN",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_MOP_CLOSE",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_MOP_GRADIENT",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_MOP_TOPHAT",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_MOP_BLACKHAT",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_TM_SQDIFF",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_TM_SQDIFF_NORMED",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_TM_CCORR",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_TM_CCORR_NORMED",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_TM_CCOEFF",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_TM_CCOEFF_NORMED",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_LKFLOW_PYR_A_READY",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_LKFLOW_PYR_B_READY",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_LKFLOW_INITIAL_GUESSES",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_LKFLOW_GET_MIN_EIGENVALS",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_POLY_APPROX_DP",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_DOMINANT_IPAN",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CONTOURS_MATCH_I1",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CONTOURS_MATCH_I2",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_CONTOURS_MATCH_I3",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_CONTOUR_TREES_MATCH_I1",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CLOCKWISE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_COUNTER_CLOCKWISE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_COMP_CORREL",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_COMP_CHISQR",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_COMP_INTERSECT",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_COMP_BHATTACHARYYA",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_VALUE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_ARRAY",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_DIST_MASK_3",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_DIST_MASK_5",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_DIST_MASK_PRECISE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_THRESH_BINARY",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_THRESH_BINARY_INV",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_THRESH_TRUNC",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_THRESH_TOZERO",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_THRESH_TOZERO_INV",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_THRESH_MASK",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_THRESH_OTSU",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_ADAPTIVE_THRESH_MEAN_C",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_ADAPTIVE_THRESH_GAUSSIAN_C",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_FLOODFILL_FIXED_RANGE",SWIG_From_int(static_cast< int >((1 << 16))));
SWIG_Python_SetConstant(d, "CV_FLOODFILL_MASK_ONLY",SWIG_From_int(static_cast< int >((1 << 17))));
SWIG_Python_SetConstant(d, "CV_CANNY_L2_GRADIENT",SWIG_From_int(static_cast< int >((1 << 31))));
SWIG_Python_SetConstant(d, "CV_HOUGH_STANDARD",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_HOUGH_PROBABILISTIC",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_HOUGH_MULTI_SCALE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_HOUGH_GRADIENT",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_HAAR_DO_CANNY_PRUNING",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_HAAR_SCALE_IMAGE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_HAAR_FIND_BIGGEST_OBJECT",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_HAAR_DO_ROUGH_SEARCH",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_LMEDS",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_RANSAC",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_CALIB_CB_ADAPTIVE_THRESH",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CALIB_CB_NORMALIZE_IMAGE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_CALIB_CB_FILTER_QUADS",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_CALIB_USE_INTRINSIC_GUESS",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_ASPECT_RATIO",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_PRINCIPAL_POINT",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_CALIB_ZERO_TANGENT_DIST",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_FOCAL_LENGTH",SWIG_From_int(static_cast< int >(16)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_K1",SWIG_From_int(static_cast< int >(32)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_K2",SWIG_From_int(static_cast< int >(64)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_K3",SWIG_From_int(static_cast< int >(128)));
SWIG_Python_SetConstant(d, "CV_CALIB_FIX_INTRINSIC",SWIG_From_int(static_cast< int >(256)));
SWIG_Python_SetConstant(d, "CV_CALIB_SAME_FOCAL_LENGTH",SWIG_From_int(static_cast< int >(512)));
SWIG_Python_SetConstant(d, "CV_CALIB_ZERO_DISPARITY",SWIG_From_int(static_cast< int >(1024)));
SWIG_Python_SetConstant(d, "CV_FM_7POINT",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_FM_8POINT",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_FM_LMEDS_ONLY",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_FM_RANSAC_ONLY",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_FM_LMEDS",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_FM_RANSAC",SWIG_From_int(static_cast< int >(8)));
SWIG_Python_SetConstant(d, "CV_STEREO_BM_NORMALIZED_RESPONSE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_STEREO_BM_BASIC",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_STEREO_BM_FISH_EYE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_STEREO_BM_NARROW",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_RETR_EXTERNAL",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_RETR_LIST",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_RETR_CCOMP",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_RETR_TREE",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_CHAIN_CODE",SWIG_From_int(static_cast< int >(0)));
SWIG_Python_SetConstant(d, "CV_CHAIN_APPROX_NONE",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_CHAIN_APPROX_SIMPLE",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_CHAIN_APPROX_TC89_L1",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_CHAIN_APPROX_TC89_KCOS",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_LINK_RUNS",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_SUBDIV2D_VIRTUAL_POINT_FLAG",SWIG_From_int(static_cast< int >((1 << 30))));
SWIG_Python_SetConstant(d, "CV_DIST_USER",SWIG_From_int(static_cast< int >(-1)));
SWIG_Python_SetConstant(d, "CV_DIST_L1",SWIG_From_int(static_cast< int >(1)));
SWIG_Python_SetConstant(d, "CV_DIST_L2",SWIG_From_int(static_cast< int >(2)));
SWIG_Python_SetConstant(d, "CV_DIST_C",SWIG_From_int(static_cast< int >(3)));
SWIG_Python_SetConstant(d, "CV_DIST_L12",SWIG_From_int(static_cast< int >(4)));
SWIG_Python_SetConstant(d, "CV_DIST_FAIR",SWIG_From_int(static_cast< int >(5)));
SWIG_Python_SetConstant(d, "CV_DIST_WELSCH",SWIG_From_int(static_cast< int >(6)));
SWIG_Python_SetConstant(d, "CV_DIST_HUBER",SWIG_From_int(static_cast< int >(7)));
SWIG_Python_SetConstant(d, "CV_HAAR_MAGIC_VAL",SWIG_From_int(static_cast< int >(0x42500000)));
SWIG_Python_SetConstant(d, "CV_TYPE_NAME_HAAR",SWIG_FromCharPtr("opencv-haar-classifier"));
SWIG_Python_SetConstant(d, "CV_HAAR_FEATURE_MAX",SWIG_From_int(static_cast< int >(3)));
SWIG_addvarlink(SWIG_globals(),(char*)"CvModule_first",Swig_var_CvModule_first_get, Swig_var_CvModule_first_set);
SWIG_addvarlink(SWIG_globals(),(char*)"CvModule_last",Swig_var_CvModule_last_get, Swig_var_CvModule_last_set);
SWIG_addvarlink(SWIG_globals(),(char*)"CvType_first",Swig_var_CvType_first_get, Swig_var_CvType_first_set);
SWIG_addvarlink(SWIG_globals(),(char*)"CvType_last",Swig_var_CvType_last_get, Swig_var_CvType_last_set);
SWIG_Python_SetConstant(d, "CV_PTLOC_ERROR",SWIG_From_int(static_cast< int >(CV_PTLOC_ERROR)));
SWIG_Python_SetConstant(d, "CV_PTLOC_OUTSIDE_RECT",SWIG_From_int(static_cast< int >(CV_PTLOC_OUTSIDE_RECT)));
SWIG_Python_SetConstant(d, "CV_PTLOC_INSIDE",SWIG_From_int(static_cast< int >(CV_PTLOC_INSIDE)));
SWIG_Python_SetConstant(d, "CV_PTLOC_VERTEX",SWIG_From_int(static_cast< int >(CV_PTLOC_VERTEX)));
SWIG_Python_SetConstant(d, "CV_PTLOC_ON_EDGE",SWIG_From_int(static_cast< int >(CV_PTLOC_ON_EDGE)));
SWIG_Python_SetConstant(d, "CV_NEXT_AROUND_ORG",SWIG_From_int(static_cast< int >(CV_NEXT_AROUND_ORG)));
SWIG_Python_SetConstant(d, "CV_NEXT_AROUND_DST",SWIG_From_int(static_cast< int >(CV_NEXT_AROUND_DST)));
SWIG_Python_SetConstant(d, "CV_PREV_AROUND_ORG",SWIG_From_int(static_cast< int >(CV_PREV_AROUND_ORG)));
SWIG_Python_SetConstant(d, "CV_PREV_AROUND_DST",SWIG_From_int(static_cast< int >(CV_PREV_AROUND_DST)));
SWIG_Python_SetConstant(d, "CV_NEXT_AROUND_LEFT",SWIG_From_int(static_cast< int >(CV_NEXT_AROUND_LEFT)));
SWIG_Python_SetConstant(d, "CV_NEXT_AROUND_RIGHT",SWIG_From_int(static_cast< int >(CV_NEXT_AROUND_RIGHT)));
SWIG_Python_SetConstant(d, "CV_PREV_AROUND_LEFT",SWIG_From_int(static_cast< int >(CV_PREV_AROUND_LEFT)));
SWIG_Python_SetConstant(d, "CV_PREV_AROUND_RIGHT",SWIG_From_int(static_cast< int >(CV_PREV_AROUND_RIGHT)));
SWIG_Python_SetConstant(d, "CV_GAUSSIAN_5x5",SWIG_From_int(static_cast< int >(CV_GAUSSIAN_5x5)));
SWIG_Python_SetConstant(d, "CvSepFilter_GENERIC",SWIG_From_int(static_cast< int >(CvSepFilter::GENERIC)));
SWIG_Python_SetConstant(d, "CvSepFilter_ASYMMETRICAL",SWIG_From_int(static_cast< int >(CvSepFilter::ASYMMETRICAL)));
SWIG_Python_SetConstant(d, "CvSepFilter_SYMMETRICAL",SWIG_From_int(static_cast< int >(CvSepFilter::SYMMETRICAL)));
SWIG_Python_SetConstant(d, "CvSepFilter_POSITIVE",SWIG_From_int(static_cast< int >(CvSepFilter::POSITIVE)));
SWIG_Python_SetConstant(d, "CvSepFilter_SUM_TO_1",SWIG_From_int(static_cast< int >(CvSepFilter::SUM_TO_1)));
SWIG_Python_SetConstant(d, "CvSepFilter_INTEGER",SWIG_From_int(static_cast< int >(CvSepFilter::INTEGER)));
SWIG_Python_SetConstant(d, "CvSepFilter_NORMALIZE_KERNEL",SWIG_From_int(static_cast< int >(CvSepFilter::NORMALIZE_KERNEL)));
SWIG_Python_SetConstant(d, "CvSepFilter_FLIP_KERNEL",SWIG_From_int(static_cast< int >(CvSepFilter::FLIP_KERNEL)));
SWIG_Python_SetConstant(d, "CvMorphology_RECT",SWIG_From_int(static_cast< int >(CvMorphology::RECT)));
SWIG_Python_SetConstant(d, "CvMorphology_CROSS",SWIG_From_int(static_cast< int >(CvMorphology::CROSS)));
SWIG_Python_SetConstant(d, "CvMorphology_ELLIPSE",SWIG_From_int(static_cast< int >(CvMorphology::ELLIPSE)));
SWIG_Python_SetConstant(d, "CvMorphology_CUSTOM",SWIG_From_int(static_cast< int >(CvMorphology::CUSTOM)));
SWIG_Python_SetConstant(d, "CvMorphology_BINARY",SWIG_From_int(static_cast< int >(CvMorphology::BINARY)));
SWIG_Python_SetConstant(d, "CvMorphology_GRAYSCALE",SWIG_From_int(static_cast< int >(CvMorphology::GRAYSCALE)));
SWIG_Python_SetConstant(d, "CvMorphology_ERODE",SWIG_From_int(static_cast< int >(CvMorphology::ERODE)));
SWIG_Python_SetConstant(d, "CvMorphology_DILATE",SWIG_From_int(static_cast< int >(CvMorphology::DILATE)));
SWIG_Python_SetConstant(d, "CvLevMarq_DONE",SWIG_From_int(static_cast< int >(CvLevMarq::DONE)));
SWIG_Python_SetConstant(d, "CvLevMarq_STARTED",SWIG_From_int(static_cast< int >(CvLevMarq::STARTED)));
SWIG_Python_SetConstant(d, "CvLevMarq_CALC_J",SWIG_From_int(static_cast< int >(CvLevMarq::CALC_J)));
SWIG_Python_SetConstant(d, "CvLevMarq_CHECK_ERR",SWIG_From_int(static_cast< int >(CvLevMarq::CHECK_ERR)));
}
| [
"garrett.marcotte@45935db4-cf16-11dd-8ca8-e3ff79f713b6"
] | [
[
[
1,
115456
]
]
] |
b3f4339be17c77ee120a7ddf9d6deb20bdd84e08 | d6eba554d0c3db3b2252ad34ffce74669fa49c58 | /Source/States/GameStates/howToState.h | 8592b77b29a04ea3ff4d4a26159018ce03e41d05 | [] | no_license | nbucciarelli/Polarity-Shift | e7246af9b8c3eb4aa0e6aaa41b17f0914f9d0b10 | 8b9c982f2938d7d1e5bd1eb8de0bdf10505ed017 | refs/heads/master | 2016-09-11T00:24:32.906933 | 2008-09-26T18:01:01 | 2008-09-26T18:01:01 | 3,408,115 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,574 | h | //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// File: "howToState.h"
// Author: Jared Hamby (JH)
// Purpose: Handles the how to state
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "menuState.h"
class CSGD_FModManager;
class howToState : public menuState
{
protected:
enum menuOptions { BACK, TOTAL };
int foregroundID;
float m_fTime, m_fXPer, m_fXLerp, m_fSoundPer, m_fSoundLerp;
CSGD_FModManager* m_pFMOD;
bool m_bMainMenu;
void menuHandler();
//int m_nParticleImageID;
howToState(void);
howToState(const howToState&);
howToState& operator=(const howToState&);
virtual ~howToState(void);
public:
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function: "getInstance"
// Last Modified: September 19th, 2008
// Purpose: Gets the instance of the singleton
//////////////////////////////////////////////////////////////////////////////////////////////////////
static howToState* getInstance();
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function: "enter"
// Last Modified: September 19th, 2008
// Purpose: enters the credits state
//////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void enter(void);
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function: "exit"
// Last Modified: September 19th, 2008
// Purpose: exits the credits state
//////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void exit(void);
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function: "udpate"
// Last Modified: September 19th, 2008
// Purpose: updates the credits state
//////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void update(float dt);
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function: "render"
// Last Modified: September 19th, 2008
// Purpose: renders the credits state
//////////////////////////////////////////////////////////////////////////////////////////////////////
virtual void render(void) const;
}; | [
"[email protected]"
] | [
[
[
1,
65
]
]
] |
515f1e74e57d4ff4c0c9f2c0aca82ed865867e0a | 7a4dfb986f5bd5fbee2186fcf37a0a0a74ef6033 | /SubtitleGrabber/HTTPRequest.cpp | b323b06f232f442e50d39c5efa1ac7d4a616402d | [] | no_license | zsjoska/subtitle-grabber | cad96727e73d6d3ec58eb3ad5eb1dfbac0c646bd | 8de1a741b2b7fdd2e7899738839516e729d23430 | refs/heads/master | 2016-09-06T19:14:26.133224 | 2007-05-30T09:20:55 | 2007-05-30T09:20:55 | 32,320,106 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,845 | cpp | #include "StdAfx.h"
#include "HTTPRequest.h"
#include "HTTP.h"
CHTTPRequest::CHTTPRequest(void)
{
m_strMethod = _T("GET");
m_strUri = _T("");
m_strServer = _T("");
m_strHTTPVer = _T("HTTP/1.1");
}
CHTTPRequest::~CHTTPRequest(void)
{
}
void CHTTPRequest::SetRequestURL( CString strURL)
{
if (strURL.Find(_T("http://"))==0)
{
strURL.Delete(0, 7);
}
int srvEnd = strURL.Find('/');
if (srvEnd < 0 )
{
m_strUri = _T("/");
m_strServer = strURL;
} else {
m_strServer = strURL.Left(srvEnd);
m_strUri = strURL.Mid(srvEnd);
}
FormatCommand();
}
void CHTTPRequest::SetMethod(CString strMethod)
{
m_strMethod = strMethod;
FormatCommand();
}
void CHTTPRequest::SetHTTPVersion(CString strHttp)
{
m_strHTTPVer = strHttp;
FormatCommand();
}
void CHTTPRequest::FormatCommand()
{
CString strCommand = m_strMethod + _T(" ") + m_strUri + _T(" ") + m_strHTTPVer;
SetTitle(strCommand);
}
BOOL CHTTPRequest::CanPersist()
{
return m_strHTTPVer == _T("HTTP/1.1") && GetHeaderField(_T("Connection"))!= _T("close");
}
LPCSTR CHTTPRequest::PrepareRequest(int & iSendCount)
{
int bodyLen = 0;
LPCSTR pszBody = ConvertFromWide(CP_UTF8, GetContent(), bodyLen);
delete [] pszBody;
TCHAR szBuff[12];
_itot_s(bodyLen-1, szBuff, 11, 10);
// bodyLen-1 since the trailing \0 must not be counted
// 11 bytes buffer, base 10
// the mandatory HTTP fields
SetHeaderString(_T("Content-Length"), szBuff );
SetHeaderString(_T("Host"), GetServer());
CString request = GetTitle() + CHTTP::CRLF + GetHeaderString() + CHTTP::CRLF + GetContent();
LPCSTR pszReq = ConvertFromWide(CP_UTF8, request, iSendCount);
// the iSendCount now contains a +1=\n we have to decrement it here since this must not be sent to the server
iSendCount--;
return pszReq;
}
| [
"zsjoska@a99920ad-ab31-0410-9f62-6da89933afc0"
] | [
[
[
1,
82
]
]
] |
25300e8fdd4e5bf6249ef0f47d97240b5f878e9e | cfa667b1f83649600e78ea53363ee71dfb684d81 | /code/tests/testgame/testgame.cc | d362c972f8c5939223148797c4417e573c2ec9c4 | [] | no_license | zhouxh1023/nebuladevice3 | c5f98a9e2c02828d04fb0e1033f4fce4119e1b9f | 3a888a7c6e6d1a2c91b7ebd28646054e4c9fc241 | refs/heads/master | 2021-01-23T08:56:15.823698 | 2011-08-26T02:22:25 | 2011-08-26T02:22:25 | 32,018,644 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 742 | cc | //------------------------------------------------------------------------------
// testviewer.cc
// (C) 2006 Radon Labs GmbH
//------------------------------------------------------------------------------
#include "stdneb.h"
#include "tests/testgame/testgameapplication.h"
ImplementNebulaApplication()
using namespace Tools;
using namespace Util;
//------------------------------------------------------------------------------
/**
*/
void
NebulaMain(const CommandLineArgs& args)
{
TestGameApplication app;
app.SetCompanyName("Radon Labs GmbH");
app.SetAppTitle("Test Game");
app.SetCmdLineArgs(args);
if (app.Open())
{
app.Run();
app.Close();
}
app.Exit();
} | [
"[email protected]"
] | [
[
[
1,
29
]
]
] |
04cfd405a178feb896d59457c17dcb8fd706791f | 5210c96be32e904a51a0f32019d6be4abdb62a6d | /SoftBody.h | 561d81327cd4647e476f53d5b0ffd4093b8431a2 | [] | no_license | Russel-Root/knot-trying-FTL | 699cec27fcf3f2b766a4beef6a58176c3cbab33e | 2c1a7992855927689ad1570dd7c5998a73728504 | refs/heads/master | 2021-01-15T13:18:35.661929 | 2011-04-02T07:51:51 | 2011-04-02T07:51:51 | 1,554,271 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 129 | h | #ifndef __SoftBody_h__
#define __SoftBody_h__
class SoftBody{
public:
SoftBody();
~SoftBody();
private:
};
#endif | [
"[email protected]"
] | [
[
[
1,
12
]
]
] |
dfbb91b24062ae2d1036534de271c47cf6382bc3 | 9a48be80edc7692df4918c0222a1640545384dbb | /Libraries/Boost1.40/libs/graph/test/cycle_ratio_tests.cpp | 821c446b90019fbb64ce15cd7e9ab11b53593650 | [
"BSL-1.0",
"Artistic-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | fcrick/RepSnapper | 05e4fb1157f634acad575fffa2029f7f655b7940 | a5809843f37b7162f19765e852b968648b33b694 | refs/heads/master | 2021-01-17T21:42:29.537504 | 2010-06-07T05:38:05 | 2010-06-07T05:38:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,651 | cpp | // Copyright (C) 2006-2009 Dmitry Bufistov and Andrey Parfenov
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <sstream>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/adjacency_matrix.hpp>
#include <boost/graph/graphviz.hpp>
#include <boost/graph/iteration_macros.hpp>
#include <boost/graph/graph_utility.hpp>
#include <boost/graph/property_iter_range.hpp>
#include <boost/graph/howard_cycle_ratio.hpp>
#include <boost/test/minimal.hpp>
/**
* @author Dmitry Bufistov
* @author Andrey Parfenov
*/
/*!
* The graph has two equal cycles with ratio 2/3
*/
static const char test_graph1[] = "digraph G {\
edge [w1=1, w2=1];\
1->2\
2->3 [w1=0]\
3->4\
4->2\
1->5\
5->6\
6->7 [w1=0]\
7->5 \
}";
/*!
* The graph has no cycles
*/
static const std::string test_graph2 = "digraph G {edge [w1=1]; 1->3 [w2=1]; 1->2 [w2=2]; 1->4 [w2=7]; }";
/*!
* Example from the paper "Nunerical computation of spectral elements"
* Maximum cycle ratio is 5.5
*/
static const char test_graph3[] = "\
digraph article {\
edge [w2 =2];\
1->1 [w1 = 1];\
1->2 [w1 = 2];\
1->4 [w1 = 7];\
2->2 [w1 = 3];\
2->3 [w1 = 5];\
3->2 [w1 = 4];\
3->4 [w1 = 3];\
4->2 [w1 = 2];\
4->3 [w1 = 8];\
}";
/*!
* Simple multigraph.
* Maximum cycle ratio is 2.5, minimum 0.5
*/
static const char test_graph4[] = "digraph G {\
edge [w2=1];\
a->b [w1=1];\
b->a [w1=0];\
a->b [w1=2];\
b->a [w1=3];\
}";
/*!
* The big graph with two equal cycles
*/
static const char test_graph5[]= "digraph G { edge [w2=1, w1=1]; n94->n8; n95->n8; n93->n8; n93->n9; n42->n9; n23->n13;\
n29->n13; n95->n14; n37->n14; n95->n19; n37->n19; n94->n23; n60->n26; n76->n26; n94->n29; n9->n33 [w1=0]; n80->n33;\
n14->n34 [w1=0];n19->n34; n94->n37; n94->n42; n95->n42; n8->n60; n26->n60; n26->n76; n106->n76; n93->n80; n42->n80;\
n33->n93; n60->n93; n13->n94; n60->n94; n34->n95; n60->n95; n94->n106; n95->n106; n93->n106;\
}";
/*!
* Random graph generated by hands.
* Maximum cycle ratio is 3.58, minimum is 0.294118
*/
static const char test_graph6[]= "digraph test_graph6 {\
16;\
17;\
\
1->2 [w1=1, w2=0.1];\
2->3 [w1 = 2, w2=3.6];\
3->4 [w1=7, w2=8];\
4->5 [w1=3.1,w2=0.8];\
4->5 [w1 = 4.2, w2=0.6];\
4->5 [w1 = 5.3, w2=0.4];\
5->6 [w1=-10, w2 = 34.75]\
6->1 [w1=100, w2 = 20]\
\
1->7 [w1=10, w2 = 20];\
7->8 [w1=3.75, w2 = 1.25];\
7->8 [w1=30, w2 = 22.2];\
8->9 [w1=10, w2 = 20];\
9->10 [w1=-2.1, w2 = 30]\
10->6 [w1=10, w2 = 20]\
\
11->12 [w1 = 5, w2=0.45];\
12->13 [w1 = 4, w2=0.2];\
13->14 [w1 = 3, w2=15.75];\
14->11 [w1 = -2.5, w2=0.6];\
11->10 [w1 = -8, w2=0.9];\
11->10 [w1 = -15, w2=2.9];\
\
18 -> 19 [w1=18, w2=6];\
18 -> 20 [w1=16.3, w2=8.2];\
18 -> 21 [w1=-3, w2=15];\
18 -> 18 [w1=2, w2=1];\
19 -> 18 [w1=0.06, w2=0.01];\
19 -> 19 [w1=1, w2=1.2];\
19 -> 20 [w1=5, w2=2];\
19 -> 21 [w1=3, w2=0.1];\
20 -> 18 [w1=4, w2=0.2];\
20 -> 19 [w1=11, w2=21];\
20 -> 20 [w1=6, w2=5];\
20 -> 21 [w1=7, w2=1];\
21 -> 18 [w1=8, w2=2];\
21 -> 19 [w1=12, w2=6];\
21 -> 20 [w1=7.5, w2=4.3];\
21 -> 21 [w1=1.25, w2=2.15];\
}";
using namespace boost;
typedef property<vertex_index_t, int, property<boost::vertex_name_t, std::string> > vertex_props_t;
template <typename TW1, typename TW2> struct Graph
{
typedef typename boost::property<
boost::edge_weight_t, TW1,
typename boost::property<
boost::edge_weight2_t, TW2, property<boost::edge_index_t, int>
>
> edge_props_t;
typedef typename boost::adjacency_list<
boost::listS, boost::listS, boost::directedS, vertex_props_t,
edge_props_t>
type;
};
typedef Graph<int, int>::type diGraphInt;
typedef Graph<double, double>::type diGraphReal;
template <typename TW1, typename TW2>
struct CEdgeProps
{
CEdgeProps(TW1 w1 = 1, TW2 w2 = 2) :
m_w1(w1), m_w2(w2), m_edge_index((std::numeric_limits<int>::max)())
{}
TW1 m_w1;
TW2 m_w2;
int m_edge_index;
};
typedef adjacency_matrix<directedS, no_property, CEdgeProps<int, int> > GraphMInt;
///Create "tokens_map" for reading graph properties from .dot file
template <typename TG>
void make_dynamic_properties(TG &g, dynamic_properties &p)
{
p.property("node_id", get(vertex_name, g));
p.property("label", get(edge_weight, g));
p.property("w1", get(edge_weight, g));
p.property("w2", get(edge_weight2, g));
}
template <typename TG>
void read_data1(std::istream &is, TG &g)
{
dynamic_properties p;
make_dynamic_properties(g, p);
read_graphviz(is, g, p);
std::cout << "Number of vertices: " << num_vertices(g) << std::endl;
std::cout << "Number of edges: " << num_edges(g) << std::endl;
int i = 0;
BGL_FORALL_VERTICES_T(vd, g, TG)
{
put(vertex_index, g, vd, i++);
}
i=0;
BGL_FORALL_EDGES_T(ed, g, TG)
{
put(edge_index, g, ed, i++);
}
}
template <typename TG>
void read_data(const char *file, TG &g)
{
std::cout << "Reading data from file: " << file << std::endl;
std::ifstream ifs(file);
BOOST_REQUIRE(ifs.good());
read_data1(ifs, g);
}
struct my_float : boost::mcr_float<>
{
static double infinity()
{
return 1000;
}
};
struct my_float2 : boost::mcr_float<>
{
static double infinity() { return 2; }
};
int test_main(int argc, char* argv[])
{
assert (argc >= 2);
using std::endl; using std::cout;
const double epsilon = 0.005;
double min_cr, max_cr; ///Minimum and maximum cycle ratio
typedef std::vector<graph_traits<diGraphInt>::edge_descriptor> ccInt_t;
typedef std::vector<graph_traits<diGraphReal>::edge_descriptor> ccReal_t;
ccInt_t cc; ///critical cycle
diGraphInt tg;
property_map<diGraphInt, vertex_index_t>::type vim = get(vertex_index, tg);
property_map<diGraphInt, edge_weight_t>::type ew1m = get(edge_weight, tg);
property_map<diGraphInt, edge_weight2_t>::type ew2m = ew2m;
{
std::istringstream iss(test_graph1);
assert(iss.good());
read_data1(iss, tg);
max_cr = maximum_cycle_ratio(tg, vim, ew1m, ew2m);
cout << "Maximum cycle ratio is " << max_cr << endl;
BOOST_CHECK(std::abs( max_cr - 0.666666666) < epsilon );
tg.clear();
}
{
std::istringstream iss(test_graph2);
read_data1(iss, tg);
// TODO: This is causing a failuire, but I'm not really sure what it's doing per se.
// Commented out for now.
// BOOST_CHECK(std::abs(maximum_cycle_ratio(tg, vim, ew1m, ew2m) + (std::numeric_limits<double>::max)()) < epsilon );
BOOST_CHECK(std::abs(boost::maximum_cycle_ratio(tg, vim, ew1m, ew2m,
static_cast<ccInt_t*>(0), my_float()) + 1000) < epsilon );
tg.clear();
}
{
std::istringstream iss(test_graph3);
diGraphInt tgi;
read_data1(iss, tgi);
double max_cr = maximum_cycle_ratio(tgi, vim, ew1m, ew2m,
static_cast<ccInt_t*>(0));
cout << "Maximum cycle ratio is " << max_cr << endl;
BOOST_CHECK(std::abs( max_cr - 2.75) < epsilon );
double maxmc = maximum_cycle_mean(tgi, vim, ew1m, get(edge_index, tgi));
cout << "Maximum cycle mean is " << maxmc << endl;
BOOST_CHECK(std::abs( maxmc - 5.5) < epsilon );
tg.clear();
}
{
std::istringstream iss(test_graph4);
read_data1(iss, tg);
max_cr = maximum_cycle_ratio(tg, vim, ew1m, ew2m);
cout << "Maximum cycle ratio is " << max_cr << endl;
BOOST_CHECK(std::abs( max_cr - 2.5) < epsilon );
min_cr = minimum_cycle_ratio(tg, vim, ew1m, ew2m);
cout << "Minimum cycle ratio is " << min_cr << endl;
BOOST_CHECK(std::abs( min_cr - 0.5) < epsilon );
tg.clear();
}
{
std::istringstream iss(test_graph5);
read_data1(iss, tg);
min_cr = minimum_cycle_ratio(tg, vim, ew1m, ew2m, &cc, my_float());
BOOST_CHECK(std::abs( min_cr - 0.666666666) < epsilon );
cout << "Minimum cycle ratio is " << min_cr << endl;
cout << "Critical cycle is:\n";
for (ccInt_t::iterator itr = cc.begin(); itr != cc.end(); ++itr)
{
cout << "(" << get(vertex_name, tg, source(*itr, tg)) <<
"," << get(vertex_name, tg, target(*itr, tg)) << ") ";
}
cout << endl;
tg.clear();
}
{
read_data(argv[1], tg);
min_cr = boost::minimum_cycle_ratio(tg, vim, ew1m, ew2m, &cc, my_float2());
cout << "Minimum cycle ratio is " << min_cr << endl;
BOOST_CHECK(std::abs(min_cr - 0.33333333333) < epsilon );
cout << "Critical cycle is:" << endl;
for (ccInt_t::iterator it = cc.begin(); it != cc.end(); ++it)
{
cout << "(" << get(vertex_name, tg, source(*it, tg)) << "," <<
get(vertex_name, tg, target(*it, tg)) << ") ";
}
cout << endl;
tg.clear();
}
{
diGraphReal tgr;
ccReal_t cc1;
std::istringstream iss(test_graph6);
read_data1(iss, tgr);
max_cr = maximum_cycle_ratio(tgr, get(vertex_index, tgr), get(edge_weight, tgr), get(edge_weight2, tgr));
cout << "Maximum cycle ratio is " << max_cr << endl;
min_cr = minimum_cycle_ratio(tgr, get(vertex_index, tgr), get(edge_weight, tgr),
get(edge_weight2, tgr), &cc);
cout << "Minimal cycle ratio is " << min_cr << endl;
std::pair<double, double> cr(.0,.0);
cout << "Critical cycle is:\n";
for (ccReal_t::iterator itr = cc.begin(); itr != cc.end(); ++itr)
{
cr.first += get(edge_weight, tgr, *itr); cr.second += get(edge_weight2, tgr, *itr);
cout << "(" << get(vertex_name, tgr, source(*itr, tgr)) << "," <<
get(vertex_name, tgr, target(*itr, tgr)) << ") ";
}
BOOST_CHECK(std::abs(cr.first / cr.second - min_cr) < epsilon);
cout << endl;
}
{
GraphMInt gm(10);
typedef graph_traits<GraphMInt>::vertex_iterator VertexItM;
typedef graph_traits<GraphMInt>::edge_descriptor EdgeM;
VertexItM vi1, vi2, vi_end;
for (tie(vi1, vi_end) = vertices(gm); vi1 != vi_end; ++vi1)
{
for (vi2 = vertices(gm).first; vi2 != vi_end; ++vi2)
add_edge(*vi1, *vi2, gm);
}
max_cr = maximum_cycle_ratio(gm, get(vertex_index, gm),
get(&CEdgeProps<int, int>::m_w1, gm), get(&CEdgeProps<int, int>::m_w2, gm));
BOOST_CHECK(std::abs(max_cr - 0.5) < epsilon);
}
return 0;
}
| [
"metrix@Blended.(none)"
] | [
[
[
1,
348
]
]
] |
12f2c6594f4fd39cbaec6aeacada0403863e6fba | ca88f025970c0d02e9e9af6deb0e335226c9f14e | /src/vec2d.h | 61e3ea9d331065fc1427883f4225edab2bd60805 | [] | no_license | c00w/rpi-os-curryrice | f073eb3128343b1274a075de49eceeaebbf32d1a | 73b6830f4a0026525c874b460c830d763ca94089 | refs/heads/master | 2016-09-05T17:27:28.660718 | 2011-10-05T02:08:49 | 2011-10-05T02:08:49 | 2,508,873 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,403 | h | #pragma once
#include "common.h"
// #pragma pack(push,1) and #pragma pack(pop) force your compiler
// to pack the structure as byte-aligned.
#pragma pack (push, 1)
//! Class for representing a 2d vector. It is guaranteed that
//! this class will have only the fields x, and y and in
//! that order, and it will be byte-aligned.
template <typename T>
class vec2d
{
public:
//! The x value
T x;
//! The y value
T y;
//! Empty constructors, sets fields to zero
inline vec2d()
{ x = y = static_cast<T>(0); }
//! Constructor taking in n
//! \param[in] n The value x and y will be set to
inline vec2d(const T& n)
{ x = y = n; }
//! Constructor taking in x and y
//! \param[in] x The initial x value
//! \param[in] y The initial y value
inline vec2d(const T& x, const T& y)
{ this->x = x; this->y = y; }
//! Constructor taking in a vector
//! \param[in] v The vector to be set to
inline vec2d(const vec2d<T>& v)
{ (*this) = v; }
//! Empty deconstructor
~vec2d() {}
//
// Comparison/Assignment overloads
//
//! Sets the second vector equal to this vector
//! \param[in] v Sets the vector equal to v
//! \return this vector
inline vec2d<T>& operator = (const vec2d& v)
{ x = v.x; y = v.y; return *this; }
//! Sets the number to all the fields of this vector
//! \param[in] n This is set to all the fields
//! \return this vector
inline vec2d<T>& operator = (const T& n)
{ x = n; y = n; return *this; }
//! Tests if the number is equal to all the fields
//! of this vector
//! \param[in] rhs The number
//! \return True if equal, false if not
inline bool operator == (const T& rhs) const
{ return (x == rhs && y == rhs); }
//! Tests if the other vector is equal to this vector
//! \param[in] rhs The other vector
//! \return True if equal, false if not
inline bool operator == (const vec2d<T>& rhs) const
{ return (x == rhs.x && y == rhs.y); }
//! Tests if the number is not equal to any of the fields
//! of this vector
//! \param[in] rhs The number
//! \return True if equal, false if not
inline bool operator != (const T& rhs) const
{ return (x != rhs || y != rhs); }
//! Tests if the other vector is not equal to this vector
//! \param[in] rhs The other vector
//! \return True if equal, false if not
inline bool operator != (const vec2d<T>& rhs) const
{ return (x != rhs.x || y != rhs.y); }
//
// Arithmetic overloads
//
//! Subtracts the other vector from this vector into
//! a new vector
//! \param[in] rhs Other vector
//! \return The subtracted vector
inline vec2d<T> operator - (const vec2d<T>& rhs) const
{ return vec2d<T>(x - rhs.x, y - rhs.y); }
//! Subtracts the number from all the fields of this vector
//! into a new vector
//! \param[in] rhs The number
//! \return The subtracted vector
inline vec2d<T> operator - (const T& rhs) const
{ return vec2d<T>(x - rhs.x, y - rhs.y); }
//! Subtracts the other vector from this vector
//! \param[in] rhs Other vector
//! \return This vector
inline vec2d<T>& operator -= (const vec2d<T>& rhs)
{ x -= rhs.x; y -= rhs.y; return *this; }
//! Subtracts the number from all the fields of this vector
//! \param[in] rhs The number
//! \return This vector
inline vec2d<T>& operator -= (const T& rhs)
{ x -= rhs; y -= rhs; return *this; }
//! Adds the other vector to this vector into
//! a new vector
//! \param[in] rhs Other vector
//! \return The added vector
inline vec2d<T> operator + (const vec2d<T>& rhs) const
{ return vec2d<T>(x + rhs.x, y + rhs.y); }
//! Adds the number to all the fields of this vector
//! into a new vector
//! \param[in] rhs The number
//! \return The added vector
inline vec2d<T> operator + (const T& rhs) const
{ return vec2d<T>(x + rhs, y + rhs); }
//! Adds the other vector to this vector
//! \param[in] rhs Other vector
//! \return This vector
inline vec2d<T>& operator += (const vec2d<T>& rhs)
{ x += rhs.x; y += rhs.y; return *this; }
//! Adds the number to all the fields of this vector
//! \param[in] rhs The number
//! \return This vector
inline vec2d<T>& operator += (const T& rhs)
{ x += rhs; y += rhs; return *this; }
//! Multiplies the other vector and this vector into
//! a new vector
//! \param[in] rhs Other vector
//! \return The multiplied vector
inline vec2d<T> operator * (const vec2d<T>& rhs) const
{ return vec2d<T>(x * rhs.x, y * rhs.y); }
//! Mutiplies the number to all the fields of this vector
//! into a new vector
//! \param[in] rhs The number
//! \return The multiplied vector
inline vec2d<T> operator * (const T& rhs) const
{ return vec2d<T>(x * rhs, y * rhs); }
//! Mutiplies the other vector to this vector
//! \param[in] rhs Other vector
//! \return This vector
inline vec2d<T>& operator *= (const vec2d<T>& rhs)
{ x *= rhs.x; y *= rhs.y; return *this; }
//! Mutiplies the number to all the fields of this vector
//! \param[in] rhs The number
//! \return This vector
inline vec2d<T>& operator *= (const T& rhs)
{ x *= rhs; y *= rhs; return *this; }
//! Divides this vector by the other vector into
//! a new vector
//! \param[in] rhs Other vector
//! \return The divided vector
inline vec2d<T> operator / (const vec2d<T>& rhs) const
{ return vec2d<T>(x / rhs.x, y / rhs.y); }
//! Divides all this vector's fields by the number
//! into a new vector
//! \param[in] rhs The number
//! \return The divided vector
inline vec2d<T> operator / (const T& rhs) const
{ return vec2d<T>(x / rhs, y / rhs); }
//! Divides this vector by the other vector
//! \param[in] rhs Other vector
//! \return This vector
inline vec2d<T>& operator /= (const vec2d<T>& rhs)
{ x /= rhs.x; y /= rhs.y; return *this; }
//! Divides all the fields of this vector by the number
//! \param[in] rhs Other number
//! \return This vector
inline vec2d<T>& operator /= (const T& rhs)
{ x /= rhs; y /= rhs; return *this; }
};
#pragma pack (pop)
typedef vec2d<float32_t> vec2df;
typedef vec2d<int> vec2di;
typedef vec2d<uint> vec2dui;
typedef vec2d<int> point2d;
typedef vec2dui size2d;
| [
"[email protected]"
] | [
[
[
1,
201
]
]
] |
ce41f4bffab135ee69c43474d75e06bbdd7a7acc | 155c4955c117f0a37bb9481cd1456b392d0e9a77 | /Tessa/TessaCodeGenerators/TessaCodeGenerator.h | 436317fcb2886cea6c7e22061100f1f4dc478d6b | [] | no_license | zwetan/tessa | 605720899aa2eb4207632700abe7e2ca157d19e6 | 940404b580054c47f3ced7cf8995794901cf0aaa | refs/heads/master | 2021-01-19T19:54:00.236268 | 2011-08-31T00:18:24 | 2011-08-31T00:18:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 778 | h |
namespace avmplus {
class AvmCore;
class MethodEnv;
class MethodInfo;
}
namespace LlvmCodeGenerator {
class LlvmJitCompiler;
}
#include <string>
namespace TessaCodeGenerators {
using namespace LlvmCodeGenerator;
using namespace std;
// Really (MethodEnv*, int argCount, Atom* arguments);
typedef int (*MethodInvoke)(avmplus::MethodEnv*, int, int*);
class TessaCodeGenerator {
private:
LlvmJitCompiler* llvmJitCompiler;
MethodInvoke _nativeCodeLocation;
std::string createMethodName(avmplus::MethodInfo* env);
public:
TessaCodeGenerator();
void compileCode(ASFunction* function, avmplus::MethodInfo* methodInfo, avmplus::AvmCore* core);
MethodInvoke getNativeCodeLocation();
static void deleteInstance();
};
} | [
"[email protected]"
] | [
[
[
1,
34
]
]
] |
be550965542ab7abf251e90909879da65c9b284a | 5eb582292aeef7c56b13bc05accf71592d15931f | /include/raknet/AsynchronousFileIO.h | 53e16f9643023a2bdc85e5be8cc16239ee8d3e20 | [] | no_license | goebish/WiiBlob | 9316a56f2a60a506ecbd856ab7c521f906b961a1 | bef78fc2fdbe2d52749ed3bc965632dd699c2fea | refs/heads/master | 2020-05-26T12:19:40.164479 | 2010-09-05T18:09:07 | 2010-09-05T18:09:07 | 188,229,195 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,986 | h | /* -*- mode: c++; c-file-style: raknet; tab-always-indent: nil; -*- */
/**
* @file
*
* @brief This file is used on win32 ports to benefits the use of IO Completion ports.
*
* @bug Currently IO Completion ports does not work correctly.
*
* This file is part of RakNet Copyright 2003 Rakkarsoft LLC and Kevin Jenkins.
*
* Usage of Raknet is subject to the appropriate licence agreement.
* "Shareware" Licensees with Rakkarsoft LLC are subject to the
* shareware license found at
* http://www.rakkarsoft.com/shareWareLicense.html which you agreed to
* upon purchase of a "Shareware license" "Commercial" Licensees with
* Rakkarsoft LLC are subject to the commercial license found at
* http://www.rakkarsoft.com/sourceCodeLicense.html which you agreed
* to upon purchase of a "Commercial license"
* Custom license users are subject to the terms therein.
* All other users are
* subject to the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* Refer to the appropriate license agreement for distribution,
* modification, and warranty rights.
*/
#ifdef __USE_IO_COMPLETION_PORTS
#ifndef __ASYNCHRONOUS_FILE_IO_H
#define __ASYNCHRONOUS_FILE_IO_H
#ifdef _WIN32
#ifdef __USE_IO_COMPLETION_PORTS
#include <WinSock2.h>
#else
#include <WinSock.h>
#endif
#include <windows.h>
#endif
#include "SimpleMutex.h"
struct ExtendedOverlappedStruct;
/**
* This class provide Asynchronous IO mecanism
*/
class AsynchronousFileIO
{
public:
/**
* Default Constructor
*/
AsynchronousFileIO();
/**
* Destructor
*/
~AsynchronousFileIO();
/**
* Associate a socket to a port
* @param socket the socket used for communication
* @param dwCompletionKey the completion port key
*/
bool AssociateSocketWithCompletionPort( SOCKET socket, DWORD dwCompletionKey );
#endif
/**
* Singleton pattern.
* Retrieve the unique instance
*/
static inline AsynchronousFileIO* Instance()
{
return & I;
}
/**
* Increase the number of user of the instance
*/
void IncreaseUserCount( void );
/**
* Decrease the number of user of the instance
*/
void DecreaseUserCount( void );
/**
* Stop using asynchronous IO
*/
void Shutdown( void );
/**
* Get the number of user of the instance
*/
int GetUserCount( void );
/**
* @todo Document this member.
*
*
*/
unsigned threadCount;
/**
* @todo Document this member.
*
*
*/
bool killThreads;
private:
HANDLE completionPort;
SimpleMutex userCountMutex;
SYSTEM_INFO systemInfo;
int userCount;
static AsynchronousFileIO I;
};
unsigned __stdcall ThreadPoolFunc( LPVOID arguments );
void WriteAsynch( HANDLE handle, ExtendedOverlappedStruct *extended );
BOOL ReadAsynch( HANDLE handle, ExtendedOverlappedStruct *extended );
#endif
| [
"[email protected]"
] | [
[
[
1,
123
]
]
] |
d687559b6f08c3c6c69a48cafabdc335899ce0ad | 6caf1a340711c6c818efc7075cc953b2f1387c04 | /client/DlgWait.cpp | a37b2176acfef8e9ab49ae610fc8271a93b38fc8 | [] | no_license | lbrucher/timelis | 35c68061bea68cc31ce1c68e3adbc23cb7f930b1 | 0fa9f8f5ef28fe02ca620c441783a1ff3fc17bde | refs/heads/master | 2021-01-01T18:18:37.988944 | 2011-08-18T19:39:19 | 2011-08-18T19:39:19 | 2,229,915 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,154 | cpp | // $Id: DlgNewDay.cpp,v 1.2 2005/01/13 12:23:20 lbrucher Exp $
//
#include "stdafx.h"
#include "DlgWait.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CDlgWait dialog
CDlgWait::CDlgWait(CWnd* pParent /*=NULL*/)
: CDialog(CDlgWait::IDD, pParent)
{
//{{AFX_DATA_INIT(CDlgWait)
m_sMessage = _T("");
//}}AFX_DATA_INIT
}
void CDlgWait::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDlgWait)
DDX_Text(pDX, IDC_MESSAGE, m_sMessage);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CDlgWait, CDialog)
//{{AFX_MSG_MAP(CDlgWait)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CDlgWait message handlers
BOOL CDlgWait::OnInitDialog()
{
CDialog::OnInitDialog();
SetWindowText(m_sTitle);
CenterWindow( GetDesktopWindow() );
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
| [
"[email protected]"
] | [
[
[
1,
51
]
]
] |
5ec70869b7cfcf2359b697e77d40f1b3fd992196 | 222bc22cb0330b694d2c3b0f4b866d726fd29c72 | /src/brookbox/wm2/WmlElement.h | c22d4431bd2a82303d84803bee88bb716755cc2b | [
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | darwin/inferno | 02acd3d05ca4c092aa4006b028a843ac04b551b1 | e87017763abae0cfe09d47987f5f6ac37c4f073d | refs/heads/master | 2021-03-12T22:15:47.889580 | 2009-04-17T13:29:39 | 2009-04-17T13:29:39 | 178,477 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,607 | h | // Magic Software, Inc.
// http://www.magic-software.com
// http://www.wild-magic.com
// Copyright (c) 2003. All Rights Reserved
//
// The Wild Magic Library (WML) source code is supplied under the terms of
// the license agreement http://www.magic-software.com/License/WildMagic.pdf
// and may not be copied or disclosed except in accordance with the terms of
// that agreement.
#ifndef WMLELEMENT_H
#define WMLELEMENT_H
#include "WmlSystem.h"
// wrappers for native types
const int WML_ELEMENT_QUANTITY = 12;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned short rgb5;
typedef unsigned int rgb8;
#define WmlDeclareElement(T) \
class WML_ITEM E##T \
{ \
public: \
E##T (T tValue = 0) { m_tValue = tValue; } \
\
E##T& operator= (E##T kElement) \
{ \
m_tValue = kElement.m_tValue; \
return *this; \
} \
\
operator T () { return m_tValue; } \
\
static int GetRTTI () { return ms_iRTTI; } \
\
protected: \
T m_tValue; \
static const int ms_iRTTI; \
}
#define WmlImplementElement(T,iRTTI) \
const int E##T::ms_iRTTI = iRTTI
namespace Wml
{
WmlDeclareElement(char);
WmlDeclareElement(uchar);
WmlDeclareElement(short);
WmlDeclareElement(ushort);
WmlDeclareElement(int);
WmlDeclareElement(uint);
WmlDeclareElement(long);
WmlDeclareElement(ulong);
WmlDeclareElement(float);
WmlDeclareElement(double);
WmlDeclareElement(rgb5);
WmlDeclareElement(rgb8);
#include "WmlElement.inl"
}
#endif
| [
"[email protected]"
] | [
[
[
1,
69
]
]
] |
ff64709d8dbfbd2b2e3dd6e14754e05a9f7bd7a7 | 1cc5720e245ca0d8083b0f12806a5c8b13b5cf98 | /v100/ok/10006/c.cpp | 3b92df2a6737d9482cbed478a2e1e31bf5d0dad0 | [] | no_license | Emerson21/uva-problems | 399d82d93b563e3018921eaff12ca545415fd782 | 3079bdd1cd17087cf54b08c60e2d52dbd0118556 | refs/heads/master | 2021-01-18T09:12:23.069387 | 2010-12-15T00:38:34 | 2010-12-15T00:38:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 768 | cpp | #include <iostream>
using namespace std;
#define FOR(a,b) for(a=0;a<b;a++)
int main() {
int ar[15];
int tot = 15;
ar[0]=561;
ar[1]=1105;
ar[2] = 1729;
ar[3] = 2465;
ar[4] = 2821;
ar[5] = 6601;
ar[6] = 8911;
ar[7] = 10585;
ar[8] = 15841;
ar[9] = 29341;
ar[10] = 41041;
ar[11] = 46657;
ar[14] = 52633;
ar[12] = 62745;
ar[13] = 63973;
int i,j;
while((cin >> i) && i) {
for(j=0;j!=tot;j++) if(ar[j]==i) break;
if(j!=tot) cout << "The number " << i << " is a Carmichael number." << endl;
else cout << i << " is normal." << endl;
}
return 0;
} | [
"[email protected]"
] | [
[
[
1,
34
]
]
] |
d71c21dcd95cc61cdf98292b7537f55b81b3fbb9 | 478570cde911b8e8e39046de62d3b5966b850384 | /apicompatanamdw/bcdrivers/app/contacts/phonebook_ui_utilities_api/inc/CPbkFieldData.h | a3b8e3aede0d356a0f795f7af82846474263e19d | [] | no_license | SymbianSource/oss.FCL.sftools.ana.compatanamdw | a6a8abf9ef7ad71021d43b7f2b2076b504d4445e | 1169475bbf82ebb763de36686d144336fcf9d93b | refs/heads/master | 2020-12-24T12:29:44.646072 | 2010-11-11T14:03:20 | 2010-11-11T14:03:20 | 72,994,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,530 | h | /*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Classes for storing Phonebook contact data in a contact database
*
*/
#ifndef __CPbkFieldData_H__
#define __CPbkFieldData_H__
// INCLUDES
#include "MPbkFieldData.h" // Abstract interfaces
// CLASS DECLARATION
/**
* @internal Only Phonebook internal use supported!
*
* Phonebook field data class.
* Implements MPbkFieldData.
*/
class CPbkFieldData :
public CBase, public MPbkFieldData
{
public: // Constructors and destructor
/**
* Creates a new text field data.
* @param aFieldId field id to create
* @param aText text to insert to field
* @return the created field data object
*/
IMPORT_C static CPbkFieldData* NewL(TPbkFieldId aFieldId,
const TDesC& aText);
/**
* Creates a new time field data.
* @param aFieldId field id to create
* @param aTime time to insert to field
* @return the created field data object
*/
IMPORT_C static CPbkFieldData* NewL(TPbkFieldId aFieldId,
const TTime& aTime);
/**
* Creates a new field data object from aStream.
* @return the created field data object
*/
IMPORT_C static CPbkFieldData* NewL(RReadStream& aStream);
/**
* Destructor.
*/
~CPbkFieldData();
public: // Interface
/**
* Returns the type of this field data.
* @return KStrorageTypeText or KStoragetTypeDateTime.
*/
inline TStorageType Type() const;
/**
* Returns the field id of this field data.
*/
inline TPbkFieldId FieldId() const;
/**
* Returns the text value of this field data.
* @exception EPanicInvalidType if Type() != KStrorageTypeText.
*/
IMPORT_C const TDesC& Text() const;
/**
* Returns the Time value of this field data.
* @exception EPanicInvalidType if Type() != KStoragetTypeDateTime.
*/
IMPORT_C const TTime& Time() const;
public: // from MPbkFieldData
IMPORT_C TStorageType PbkFieldType() const;
IMPORT_C TPbkFieldId PbkFieldId() const;
IMPORT_C TPtrC PbkFieldText() const;
IMPORT_C TTime PbkFieldTime() const;
public: // Externalize/internalize
/**
* Externalizes this object to aStream.
*/
IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
/**
* Internalizes this object from aStream.
*/
IMPORT_C void InternalizeL(RReadStream& aStream);
private: // Implementation
CPbkFieldData();
void ConstructL(TPbkFieldId aFieldId, const TDesC& aText);
void ConstructL(TPbkFieldId aFieldId, const TTime& aTime);
void ConstructL(RReadStream& aStream);
private: // Data
/// Type enum
enum TType
{
/// Text data
ETypeText = KStorageTypeText,
/// Time data
ETypeTime = KStorageTypeDateTime
};
/// Own: type
TType iType;
/// Own: field id
TPbkFieldId iFieldId;
/// Own: text data
HBufC* iText;
/// Own: time data
TTime iTime;
};
/**
* Array of CPbkFieldData objects.
*/
class CPbkFieldDataArray :
public CArrayPtrFlat<CPbkFieldData>,
public MPbkFieldDataArray
{
public: // Constructors and destructor
/**
* Creates an instance of this class.
* @return Newly created instance of this class.
*/
IMPORT_C static CPbkFieldDataArray* NewL();
/**
* Creates an instance of this class from aStream.
* @return Newly created instance of this class.
*/
IMPORT_C static CPbkFieldDataArray* NewL(RReadStream& aStream);
// Compiler-generated destructor is ok for this class.
public: // New functions
/**
* Pushes a cleanup item which will call ResetAndDestroy() for this
* array when PopAndDestroy()'ed.
*/
IMPORT_C void ResetAndDestroyPushL();
/**
* Externalizes this object to aStream.
*/
IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
/**
* Internalizes this object from aStream.
*/
IMPORT_C void InternalizeL(RReadStream& aStream);
public: // from MPbkFieldDataArray
TInt PbkFieldCount() const;
MPbkFieldData& PbkFieldAt(TInt aIndex);
const MPbkFieldData& PbkFieldAt(TInt aIndex) const;
private: // Implementation
CPbkFieldDataArray();
static void CleanupResetAndDestroy(TAny* aSelf);
};
// INLINE FUNCTIONS
inline TStorageType CPbkFieldData::Type() const
{
return iType;
}
inline TPbkFieldId CPbkFieldData::FieldId() const
{
return iFieldId;
}
#endif // __CPbkFieldData_H__
// End of File
| [
"none@none"
] | [
[
[
1,
198
]
]
] |
c17fd3279fa250554453ed3885ead6bc5799c9ae | ad80c85f09a98b1bfc47191c0e99f3d4559b10d4 | /code/src/particle/npservemit_cmds.cc | 12df135bf74181114e2cb798afee415cac7358b6 | [] | no_license | DSPNerd/m-nebula | 76a4578f5504f6902e054ddd365b42672024de6d | 52a32902773c10cf1c6bc3dabefd2fd1587d83b3 | refs/heads/master | 2021-12-07T18:23:07.272880 | 2009-07-07T09:47:09 | 2009-07-07T09:47:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 503 | cc | #define N_IMPLEMENTS nPServEmitter
//-------------------------------------------------------------------
// npservemit_cmds.cc
// (C) 2000 A.Weissflog
//-------------------------------------------------------------------
//------------------------------------------------------------------------------
/**
@scriptclass
npservemitter
@superclass
npemitter
@classinfo
Super class for all particle emitters that use particle server
systems (dont use).
*/
| [
"plushe@411252de-2431-11de-b186-ef1da62b6547"
] | [
[
[
1,
18
]
]
] |
e9cfe336d5e1aa4aa762e1cabbd4f86ebae08b6a | 38664d844d9fad34e88160f6ebf86c043db9f1c5 | /branches/initialize/skin/Samples/Skinmagic Toolkit 2.4/MFC/FormViewDemo/FormViewDemoDoc.h | 0ed61dc648daeddbefa7576a75fa785596f9b912 | [] | no_license | cnsuhao/jezzitest | 84074b938b3e06ae820842dac62dae116d5fdaba | 9b5f6cf40750511350e5456349ead8346cabb56e | refs/heads/master | 2021-05-28T23:08:59.663581 | 2010-11-25T13:44:57 | 2010-11-25T13:44:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,541 | h | // FormViewDemoDoc.h : interface of the CFormViewDemoDoc class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_FORMVIEWDEMODOC_H__3D3A1C4E_F05B_41BE_8D95_B5199CFD8D82__INCLUDED_)
#define AFX_FORMVIEWDEMODOC_H__3D3A1C4E_F05B_41BE_8D95_B5199CFD8D82__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CFormViewDemoDoc : public CDocument
{
protected: // create from serialization only
CFormViewDemoDoc();
DECLARE_DYNCREATE(CFormViewDemoDoc)
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CFormViewDemoDoc)
public:
virtual BOOL OnNewDocument();
virtual void Serialize(CArchive& ar);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CFormViewDemoDoc();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CFormViewDemoDoc)
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_FORMVIEWDEMODOC_H__3D3A1C4E_F05B_41BE_8D95_B5199CFD8D82__INCLUDED_)
| [
"zhongzeng@ba8f1dc9-3c1c-0410-9eed-0f8a660c14bd"
] | [
[
[
1,
57
]
]
] |
3edc32683646efd8dc38133c6d4ad2dd68c197a9 | 1b2eb18a7d77e160bf992f952767198fe00fe10e | /trunk/096/pkg/OLD/mobiles/oldAI/main/mainLoopAnimal.inc | 7f6f9d43de6e96ce1345c3526179e7de5935d52b | [] | no_license | BackupTheBerlios/poldistro-svn | 96fd832f9a7479bdc4d00501af45a14a3c571c0f | 251f022debb3e4d4ff3c9c43f3bf1029f15e47b1 | refs/heads/master | 2020-05-18T14:11:44.348758 | 2006-05-20T16:06:44 | 2006-05-20T16:06:44 | 40,800,663 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,234 | inc | function main_AI_loop()
var wanders := 60;
EnableMainEvents();
while(1)
wander();
wanders := wanders +1;
if(wanders > 60)
wanders :=0;
ev := sleepmode();
else
ev := os::wait_for_event(5);
endif
if(ev)
repeat
case(ev.type)
SYSEVENT_DAMAGED: Fight(ev.source);
SYSEVENT_ENGAGED: Fight(ev.source);
EVID_HERDING: HerdingLoop(ev);
endcase
until(!(ev := os::wait_for_event(5)));
endif
endwhile
endfunction
function RunLikeHell(opponent)
var ev;
while((opponent)&& not(opponent.dead || opponent.hidden || opponent.concealed)&&(Distance(me,opponent)< 25))
WalkAwayFrom(opponent);
repeat
case(ev.type)
SYSEVENT_DAMAGED: Fight(ev.source); return;
endcase
until(!(ev := os::wait_for_event(1)));
endwhile
endfunction
function look_around()
return;
endfunction
function EnableMainEvents()
EnableEvents(EVID_HERDING);
DisableEvents(SYSEVENT_ENTEREDAREA + SYSEVENT_SPEECH + SYSEVENT_LEFTAREA + SYSEVENT_DISENGAGED + SYSEVENT_OPPONENT_MOVED);
EnableEvents(SYSEVENT_ENGAGED + SYSEVENT_DAMAGED, HALT_THRESHOLD);
endfunction
function DisableMainEvents()
DisableEvents(SYSEVENT_SPEECH + SYSEVENT_ENGAGED + SYSEVENT_DAMAGED + SYSEVENT_ENTEREDAREA);
endfunction
function HerdingLoop(ev)
var holder := ev.data;
var lx := holder[1];
var ly := holder[2];
var loops := 0;
var opponent;
while(1)
if(!CloseIn(me, lx, ly))
loops := loops + 1;
waittime := 0;
else
loops := 0;
waittime := 1;
endif
if((loops >= 30) or (CoordinateDistance(me.x, me.y, lx, ly) <= 1))
break;
endif
ev := wait_for_event(waittime);
case (ev.type)
SYSEVENT_DAMAGED: opponent := ev.source;
SetOpponent(opponent);
TurnToward(opponent);
SYSEVENT_ENGAGED: opponent := ev.source;
SetOpponent(opponent);
TurnToward(opponent);
endcase
endwhile
Return;
endfunction
function CloseIn(me, lx, ly)
case (CoordinateDistance(me.x, me.y, lx, ly))
0: return 1;
default: WalkTowardLocation(lx, ly);
return 0;
endcase
endfunction | [
"austin@9d346cd0-66fc-0310-bdc5-e57197e5a75e"
] | [
[
[
1,
87
]
]
] |
2e1a075a264fa630bd4ed1697f9a42f99be4b9fa | cd0987589d3815de1dea8529a7705caac479e7e9 | /webkit/WebKit/haiku/WebCoreSupport/FrameLoaderClientHaiku.cpp | 364cdf768916886444270ddbf1ac072a80daff02 | [
"BSD-2-Clause"
] | permissive | azrul2202/WebKit-Smartphone | 0aab1ff641d74f15c0623f00c56806dbc9b59fc1 | 023d6fe819445369134dee793b69de36748e71d7 | refs/heads/master | 2021-01-15T09:24:31.288774 | 2011-07-11T11:12:44 | 2011-07-11T11:12:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,324 | cpp | /*
* Copyright (C) 2006 Don Gibson <[email protected]>
* Copyright (C) 2006 Zack Rusin <[email protected]>
* Copyright (C) 2006 Apple Computer, Inc. All rights reserved.
* Copyright (C) 2007 Trolltech ASA
* Copyright (C) 2007 Ryan Leavengood <[email protected]> All rights reserved.
* Copyright (C) 2009 Maxime Simon <[email protected]> All rights reserved.
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "FrameLoaderClientHaiku.h"
#include "DocumentLoader.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "FrameTree.h"
#include "FrameView.h"
#include "HTMLFrameOwnerElement.h"
#include "NotImplemented.h"
#include "Page.h"
#include "PlatformString.h"
#include "ResourceRequest.h"
#include "ScriptController.h"
#include "WebView.h"
#include <Message.h>
#include <String.h>
#include <app/Messenger.h>
namespace WebCore {
FrameLoaderClientHaiku::FrameLoaderClientHaiku()
: m_frame(0)
{
}
void FrameLoaderClientHaiku::setFrame(Frame* frame)
{
m_frame = frame;
}
void FrameLoaderClientHaiku::setWebView(WebView* webview)
{
m_webView = webview;
m_messenger = new BMessenger(m_webView);
ASSERT(m_messenger->IsValid());
}
void FrameLoaderClientHaiku::detachFrameLoader()
{
m_frame = 0;
}
bool FrameLoaderClientHaiku::hasWebView() const
{
return m_webView;
}
bool FrameLoaderClientHaiku::hasBackForwardList() const
{
notImplemented();
return true;
}
void FrameLoaderClientHaiku::resetBackForwardList()
{
notImplemented();
}
bool FrameLoaderClientHaiku::provisionalItemIsTarget() const
{
notImplemented();
return false;
}
void FrameLoaderClientHaiku::makeRepresentation(DocumentLoader*)
{
notImplemented();
}
void FrameLoaderClientHaiku::forceLayout()
{
notImplemented();
}
void FrameLoaderClientHaiku::forceLayoutForNonHTML()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryForCommit()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryForBackForwardNavigation()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryForReload()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryForStandardLoad()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryForInternalLoad()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateHistoryAfterClientRedirect()
{
notImplemented();
}
void FrameLoaderClientHaiku::setCopiesOnScroll()
{
// apparently mac specific
notImplemented();
}
LoadErrorResetToken* FrameLoaderClientHaiku::tokenForLoadErrorReset()
{
notImplemented();
return 0;
}
void FrameLoaderClientHaiku::resetAfterLoadError(LoadErrorResetToken*)
{
notImplemented();
}
void FrameLoaderClientHaiku::doNotResetAfterLoadError(LoadErrorResetToken*)
{
notImplemented();
}
void FrameLoaderClientHaiku::willCloseDocument()
{
notImplemented();
}
void FrameLoaderClientHaiku::detachedFromParent2()
{
notImplemented();
}
void FrameLoaderClientHaiku::detachedFromParent3()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidHandleOnloadEvents()
{
if (m_webView) {
BMessage message(LOAD_ONLOAD_HANDLE);
message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::dispatchDidReceiveServerRedirectForProvisionalLoad()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidCancelClientRedirect()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidChangeLocationWithinPage()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidPushStateWithinPage()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidReplaceStateWithinPage()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidPopStateWithinPage()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchWillClose()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidStartProvisionalLoad()
{
if (m_webView) {
BMessage message(LOAD_NEGOCIATING);
message.AddString("url", m_frame->loader()->provisionalDocumentLoader()->request().url().string());
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::dispatchDidReceiveTitle(const String& title)
{
if (m_webView) {
m_webView->SetPageTitle(title);
BMessage message(TITLE_CHANGED);
message.AddString("title", title);
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::dispatchDidCommitLoad()
{
if (m_webView) {
BMessage message(LOAD_TRANSFERRING);
message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::dispatchDidFinishDocumentLoad()
{
if (m_webView) {
BMessage message(LOAD_DOC_COMPLETED);
message.AddString("url", m_frame->loader()->url().string());
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::dispatchDidFinishLoad()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidFirstLayout()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidFirstVisuallyNonEmptyLayout()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchShow()
{
notImplemented();
}
void FrameLoaderClientHaiku::cancelPolicyCheck()
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState>)
{
// FIXME: Send an event to allow for alerts and cancellation.
if (!m_frame)
return;
(m_frame->loader()->policyChecker()->*function)(PolicyUse);
}
void FrameLoaderClientHaiku::dispatchDidLoadMainResource(DocumentLoader*)
{
notImplemented();
}
void FrameLoaderClientHaiku::revertToProvisionalState(DocumentLoader*)
{
notImplemented();
}
void FrameLoaderClientHaiku::postProgressStartedNotification()
{
notImplemented();
}
void FrameLoaderClientHaiku::postProgressEstimateChangedNotification()
{
notImplemented();
}
void FrameLoaderClientHaiku::postProgressFinishedNotification()
{
if (m_webView) {
BMessage message(LOAD_DL_COMPLETED);
message.AddString("url", m_frame->loader()->url().string());
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::progressStarted()
{
notImplemented();
}
void FrameLoaderClientHaiku::progressCompleted()
{
notImplemented();
}
void FrameLoaderClientHaiku::setMainFrameDocumentReady(bool)
{
notImplemented();
// this is only interesting once we provide an external API for the DOM
}
void FrameLoaderClientHaiku::willChangeTitle(DocumentLoader*)
{
notImplemented();
}
void FrameLoaderClientHaiku::didChangeTitle(DocumentLoader* docLoader)
{
setTitle(docLoader->title(), docLoader->url());
}
void FrameLoaderClientHaiku::finishedLoading(DocumentLoader*)
{
notImplemented();
}
bool FrameLoaderClientHaiku::canShowMIMETypeAsHTML(const String& MIMEType) const
{
notImplemented();
return false;
}
bool FrameLoaderClientHaiku::canShowMIMEType(const String& MIMEType) const
{
notImplemented();
return true;
}
bool FrameLoaderClientHaiku::representationExistsForURLScheme(const String& URLScheme) const
{
notImplemented();
return false;
}
String FrameLoaderClientHaiku::generatedMIMETypeForURLScheme(const String& URLScheme) const
{
notImplemented();
return String();
}
void FrameLoaderClientHaiku::frameLoadCompleted()
{
if (m_webView->LockLooper()) {
m_webView->Draw(m_webView->Bounds());
m_webView->UnlockLooper();
}
}
void FrameLoaderClientHaiku::saveViewStateToItem(HistoryItem*)
{
notImplemented();
}
void FrameLoaderClientHaiku::restoreViewState()
{
notImplemented();
}
void FrameLoaderClientHaiku::restoreScrollPositionAndViewState()
{
notImplemented();
}
void FrameLoaderClientHaiku::provisionalLoadStarted()
{
notImplemented();
}
bool FrameLoaderClientHaiku::shouldTreatURLAsSameAsCurrent(const KURL&) const
{
notImplemented();
return false;
}
void FrameLoaderClientHaiku::addHistoryItemForFragmentScroll()
{
notImplemented();
}
void FrameLoaderClientHaiku::didFinishLoad()
{
notImplemented();
}
void FrameLoaderClientHaiku::prepareForDataSourceReplacement()
{
notImplemented();
}
void FrameLoaderClientHaiku::setTitle(const String& title, const KURL&)
{
notImplemented();
}
String FrameLoaderClientHaiku::userAgent(const KURL&)
{
return String("Mozilla/5.0 (compatible; U; InfiNet 0.1; Haiku) AppleWebKit/420+ (KHTML, like Gecko)");
}
void FrameLoaderClientHaiku::dispatchDidReceiveIcon()
{
notImplemented();
}
void FrameLoaderClientHaiku::frameLoaderDestroyed()
{
m_frame = 0;
m_messenger = 0;
delete this;
}
bool FrameLoaderClientHaiku::canHandleRequest(const WebCore::ResourceRequest&) const
{
notImplemented();
return true;
}
void FrameLoaderClientHaiku::partClearedInBegin()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateGlobalHistory()
{
notImplemented();
}
void FrameLoaderClientHaiku::updateGlobalHistoryRedirectLinks()
{
notImplemented();
}
bool FrameLoaderClientHaiku::shouldGoToHistoryItem(WebCore::HistoryItem*) const
{
notImplemented();
return true;
}
void FrameLoaderClientHaiku::dispatchDidAddBackForwardItem(WebCore::HistoryItem*) const
{
}
void FrameLoaderClientHaiku::dispatchDidRemoveBackForwardItem(WebCore::HistoryItem*) const
{
}
void FrameLoaderClientHaiku::dispatchDidChangeBackForwardIndex() const
{
}
void FrameLoaderClientHaiku::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
{
notImplemented();
}
bool FrameLoaderClientHaiku::canCachePage() const
{
return false;
}
void FrameLoaderClientHaiku::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
{
notImplemented();
}
void FrameLoaderClientHaiku::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
{
loader->commitData(data, length);
}
WebCore::ResourceError FrameLoaderClientHaiku::cancelledError(const WebCore::ResourceRequest& request)
{
notImplemented();
return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
}
WebCore::ResourceError FrameLoaderClientHaiku::blockedError(const ResourceRequest& request)
{
notImplemented();
return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
}
WebCore::ResourceError FrameLoaderClientHaiku::cannotShowURLError(const WebCore::ResourceRequest& request)
{
return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
}
WebCore::ResourceError FrameLoaderClientHaiku::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
{
notImplemented();
return ResourceError(String(), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(), String());
}
WebCore::ResourceError FrameLoaderClientHaiku::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
{
notImplemented();
return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url().string(), String());
}
WebCore::ResourceError FrameLoaderClientHaiku::fileDoesNotExistError(const WebCore::ResourceResponse& response)
{
notImplemented();
return ResourceError(String(), WebKitErrorCannotShowURL, response.url().string(), String());
}
bool FrameLoaderClientHaiku::shouldFallBack(const WebCore::ResourceError& error)
{
notImplemented();
return false;
}
WTF::PassRefPtr<DocumentLoader> FrameLoaderClientHaiku::createDocumentLoader(const ResourceRequest& request,
const SubstituteData& substituteData)
{
return DocumentLoader::create(request, substituteData);
}
void FrameLoaderClientHaiku::download(ResourceHandle*, const ResourceRequest&,
const ResourceRequest&, const ResourceResponse&)
{
notImplemented();
}
void FrameLoaderClientHaiku::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*,
const ResourceRequest&)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request,
const ResourceResponse& response)
{
notImplemented();
}
bool FrameLoaderClientHaiku::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
{
notImplemented();
return false;
}
void FrameLoaderClientHaiku::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*,
unsigned long, const AuthenticationChallenge&)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidCancelAuthenticationChallenge(DocumentLoader*,
unsigned long, const AuthenticationChallenge&)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id,
const ResourceResponse& response)
{
notImplemented();
m_response = response;
m_firstData = true;
}
void FrameLoaderClientHaiku::dispatchDidReceiveContentLength(DocumentLoader* loader,
unsigned long id, int length)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidFailLoading(DocumentLoader* loader,
unsigned long, const ResourceError&)
{
if (m_webView) {
BMessage message(LOAD_FAILED);
message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
m_messenger->SendMessage(&message);
}
}
bool FrameLoaderClientHaiku::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*,
const ResourceRequest&,
const ResourceResponse&, int)
{
notImplemented();
return false;
}
void FrameLoaderClientHaiku::dispatchDidFailProvisionalLoad(const ResourceError&)
{
notImplemented();
}
void FrameLoaderClientHaiku::dispatchDidFailLoad(const ResourceError&)
{
notImplemented();
}
Frame* FrameLoaderClientHaiku::dispatchCreatePage()
{
notImplemented();
return false;
}
void FrameLoaderClientHaiku::dispatchDecidePolicyForMIMEType(FramePolicyFunction function,
const String& mimetype,
const ResourceRequest& request)
{
if (!m_frame)
return;
notImplemented();
(m_frame->loader()->policyChecker()->*function)(PolicyUse);
}
void FrameLoaderClientHaiku::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function,
const NavigationAction&,
const ResourceRequest& request,
PassRefPtr<FormState>, const String& targetName)
{
if (!m_frame)
return;
if (m_webView) {
BMessage message(NEW_WINDOW_REQUESTED);
message.AddString("url", request.url().string());
if (m_messenger->SendMessage(&message)) {
(m_frame->loader()->policyChecker()->*function)(PolicyIgnore);
return;
}
}
(m_frame->loader()->policyChecker()->*function)(PolicyUse);
}
void FrameLoaderClientHaiku::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function,
const NavigationAction& action,
const ResourceRequest& request,
PassRefPtr<FormState>)
{
if (!m_frame || !function)
return;
if (m_webView) {
BMessage message(NAVIGATION_REQUESTED);
message.AddString("url", request.url().string());
m_messenger->SendMessage(&message);
(m_frame->loader()->policyChecker()->*function)(PolicyUse);
}
}
void FrameLoaderClientHaiku::dispatchUnableToImplementPolicy(const ResourceError&)
{
notImplemented();
}
void FrameLoaderClientHaiku::startDownload(const ResourceRequest&)
{
notImplemented();
}
PassRefPtr<Frame> FrameLoaderClientHaiku::createFrame(const KURL& url, const String& name,
HTMLFrameOwnerElement* ownerElement,
const String& referrer, bool allowsScrolling,
int marginWidth, int marginHeight)
{
// FIXME: We should apply the right property to the frameView. (scrollbar,margins)
RefPtr<Frame> childFrame = Frame::create(m_frame->page(), ownerElement, this);
setFrame(childFrame.get());
RefPtr<FrameView> frameView = FrameView::create(childFrame.get());
frameView->setAllowsScrolling(allowsScrolling);
frameView->deref();
childFrame->setView(frameView.get());
childFrame->init();
childFrame->tree()->setName(name);
m_frame->tree()->appendChild(childFrame);
childFrame->loader()->loadURLIntoChildFrame(url, referrer, childFrame.get());
// The frame's onload handler may have removed it from the document.
if (!childFrame->tree()->parent())
return 0;
return childFrame.release();
notImplemented();
return 0;
}
void FrameLoaderClientHaiku::didTransferChildFrameToNewDocument()
{
}
ObjectContentType FrameLoaderClientHaiku::objectContentType(const KURL& url, const String& mimeType)
{
notImplemented();
return ObjectContentType();
}
PassRefPtr<Widget> FrameLoaderClientHaiku::createPlugin(const IntSize&, HTMLPlugInElement*,
const KURL&, const Vector<String>&,
const Vector<String>&, const String&,
bool loadManually)
{
notImplemented();
return 0;
}
void FrameLoaderClientHaiku::redirectDataToPlugin(Widget* pluginWidget)
{
notImplemented();
return;
}
ResourceError FrameLoaderClientHaiku::pluginWillHandleLoadError(const ResourceResponse& response)
{
notImplemented();
return ResourceError(String(), WebKitErrorCannotLoadPlugIn, response.url().string(), String());
}
PassRefPtr<Widget> FrameLoaderClientHaiku::createJavaAppletWidget(const IntSize&, HTMLAppletElement*,
const KURL& baseURL,
const Vector<String>& paramNames,
const Vector<String>& paramValues)
{
notImplemented();
return 0;
}
String FrameLoaderClientHaiku::overrideMediaType() const
{
notImplemented();
return String();
}
void FrameLoaderClientHaiku::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
{
if (world != mainThreadNormalWorld())
return;
if (m_webView) {
BMessage message(JAVASCRIPT_WINDOW_OBJECT_CLEARED);
m_messenger->SendMessage(&message);
}
}
void FrameLoaderClientHaiku::documentElementAvailable()
{
}
void FrameLoaderClientHaiku::didPerformFirstNavigation() const
{
notImplemented();
}
void FrameLoaderClientHaiku::registerForIconNotification(bool listen)
{
notImplemented();
}
void FrameLoaderClientHaiku::savePlatformDataToCachedFrame(CachedFrame*)
{
notImplemented();
}
void FrameLoaderClientHaiku::transitionToCommittedFromCachedFrame(CachedFrame*)
{
notImplemented();
}
void FrameLoaderClientHaiku::transitionToCommittedForNewPage()
{
ASSERT(m_frame);
ASSERT(m_webView);
Page* page = m_frame->page();
ASSERT(page);
bool isMainFrame = m_frame == page->mainFrame();
m_frame->setView(0);
RefPtr<FrameView> frameView;
if (isMainFrame) {
if (m_webView->LockLooper()) {
// We lock the looper in order to get the bounds of the WebView.
frameView = FrameView::create(m_frame, IntRect(m_webView->Bounds()).size());
m_webView->UnlockLooper();
}
} else
frameView = FrameView::create(m_frame);
ASSERT(frameView);
m_frame->setView(frameView);
frameView->setPlatformWidget(m_webView);
if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
m_frame->view()->setScrollbarModes(owner->scrollingMode(), owner->scrollingMode());
}
} // namespace WebCore
| [
"[email protected]"
] | [
[
[
1,
857
]
]
] |
9342b0699b84631dfa4768da3615832c7744b241 | 28e96305e2659b581a6a8002c795e52dd6fbd53c | /zAudio/main.cpp | 2f26dff614e8758425c6c1da798c80afe4241296 | [] | no_license | situr/open-magx-src | 970cd649903b223292d9274478d97f161ba52006 | 87bea580360c7fcf8270b642cc38b65252e6b1cc | refs/heads/master | 2020-12-25T09:47:07.262768 | 2011-11-16T03:37:49 | 2011-11-16T03:37:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 472 | cpp | //
// Poject name: zAudio
//
// Version: 0.1
//
// Description: Programm for change audio settings
//
// Author: Ant-ON <[email protected]>, (C) 2010
//
#include "zgui.h"
#include <ZApplication.h>
ZGui* zgui;
ZApplication* app;
int main ( int argc, char **argv )
{
app = new ZApplication ( argc, argv );
int ret;
zgui = new ZGui ( NULL, NULL );
ret = app->exec();
delete zgui;
zgui = NULL;
delete app;
app = NULL;
return ret;
}
| [
"[email protected]"
] | [
[
[
1,
28
]
]
] |
b552bd3db798fbcfcdba762783dcaab1f44ab071 | 71ffdff29137de6bda23f02c9e22a45fe94e7910 | /LevelEditor/src/CApp.cpp | 9d89c5386f4b521d11fd47e6af8a2992209b5ebd | [] | no_license | anhoppe/killakoptuz3000 | f2b6ecca308c1d6ebee9f43a1632a2051f321272 | fbf2e77d16c11abdadf45a88e1c747fa86517c59 | refs/heads/master | 2021-01-02T22:19:10.695739 | 2009-03-15T21:22:31 | 2009-03-15T21:22:31 | 35,839,301 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 979 | cpp | // ***************************************************************
// CApp version: 1.0 · date: 06/18/2007
// -------------------------------------------------------------
//
// -------------------------------------------------------------
// Copyright (C) 2007 - All Rights Reserved
// ***************************************************************
//
// ***************************************************************
#include "CApp.h"
#include "gui/CMainFrame.h"
IMPLEMENT_APP(CApp)
bool CApp::OnInit()
{
m_mainFramePtr = new CMainFrame();
m_mainFramePtr->Show();
return true;
}
int CApp::OnExit()
{
return 69;
}
int CApp::FilterEvent(wxEvent& t_event)
{
int r_result = -1;
if(t_event.GetEventType() == wxEVT_KEY_DOWN)
{
wxKeyEvent* a_keyEvent = static_cast<wxKeyEvent*>(&t_event);
m_mainFramePtr->onKeyDown(*a_keyEvent);
r_result = FALSE;
}
return r_result;
}
| [
"anhoppe@9386d06f-8230-0410-af72-8d16ca8b68df"
] | [
[
[
1,
44
]
]
] |
d3ba6ceb2bb61663596beceaa365ffef9070c7d5 | 8a3fce9fb893696b8e408703b62fa452feec65c5 | /priority_queue/priority_queue/Timer.cpp | f25c2b5bff36dc66cb57594b48e35326006b65fa | [] | no_license | win18216001/tpgame | bb4e8b1a2f19b92ecce14a7477ce30a470faecda | d877dd51a924f1d628959c5ab638c34a671b39b2 | refs/heads/master | 2021-04-12T04:51:47.882699 | 2011-03-08T10:04:55 | 2011-03-08T10:04:55 | 42,728,291 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 422 | cpp | #include "StdAfx.h"
#include "Timer.h"
CTimer::CTimer(void)
{
}
CTimer::~CTimer(void)
{
}
long CTimer::AddTimer(const void * arg, unsigned long stime, unsigned long interval)
{
return m_Timer.AddTimer( static_cast<CGameEvent*>(const_cast<void*>(arg)) , stime , interval );
}
long CTimer::run()
{
while ( 1 )
{
m_Timer.Expired( timeGetTime() );
Sleep( 1 );
}
return 0;
}
| [
"[email protected]"
] | [
[
[
1,
29
]
]
] |
f0555de9db308685ac2cfefdf172a5955b88fb0e | a70f708a62feb4d1b6f80d0a471b47ac584ea82b | / arxlss --username quangvinh.ph/VLSS/Funcs.cpp | 27e8408af6152c1a7bfaaa597b9c43adb6e99edd | [] | no_license | presscad/arxlss | ae8a41acba416d20a1ec2aa4485d142912e6787d | d6d201bfc98b0d442c77b37b10ca5ac7ea5efcbb | refs/heads/master | 2021-04-01T22:38:06.710239 | 2009-11-07T02:47:17 | 2009-11-07T02:47:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,142 | cpp |
#ifndef FUNCS_H
#define FUNCS_H
#include "StdAfx.h"
#include "Resource.h"
#include "Lessons.h"
#include "Logger.h"
/************************************************************************/
/* FUNCTIONS ARE IMPLEMENTED HERE
/************************************************************************/
int getBlockRefAll(AcDbObjectIdArray& idaAll)
{
Acad::ErrorStatus esResult;
idaAll.setLogicalLength(0);
// Get the current working database.
AcDbDatabase* pDb = acDocManager->curDocument()->database();
// Get the BlockTable.
AcDbBlockTable* pBlockTable = NULL;
esResult = pDb->getBlockTable(pBlockTable, AcDb::kForRead);
if (Acad::eOk != esResult)
return 0;
// Get the Model Space.
AcDbBlockTableRecord* pModelSpace = NULL;
esResult = pBlockTable->getAt(ACDB_MODEL_SPACE, pModelSpace, AcDb::kForRead);
pBlockTable->close();
if (Acad::eOk != esResult)
return 0;
// Get the Iterator of ModelSpace
AcDbBlockTableRecordIterator* pRcdIter = NULL;
esResult = pModelSpace->newIterator(pRcdIter);
pModelSpace->close();
if (Acad::eOk != esResult)
return 0;
for (; !pRcdIter->done(); pRcdIter->step()) {
AcDbEntity* pEntity = NULL;
if (Acad::eOk != (pRcdIter->getEntity(pEntity, AcDb::kForRead)))
continue;
if (pEntity->isKindOf(AcDbBlockReference::desc())) {
AcDbObjectId idObj = pEntity->objectId();
idaAll.append(idObj);
}
pEntity->close();
}
delete pRcdIter;
return idaAll.length();
}
AcDbObject* selectObject(AcDb::OpenMode mode)
{
ads_name adsName;
ads_point adsPoint;
if (RTNORM != acedEntSel(ACRX_T("\nSpecify an entity: "), adsName, adsPoint))
return NULL;
AcDbObject* pObj = NULL;
AcDbObjectId idObj = AcDbObjectId::kNull;
if (Acad::eOk != acdbGetObjectId(idObj, adsName))
return NULL;
if( Acad::eOk != acdbOpenObject(pObj, idObj, mode))
return NULL;
return pObj;
}
AcDbEntity* selectEntity(AcDb::OpenMode mode)
{
ads_name adsName;
ads_point adsPoint;
if (RTNORM != acedEntSel(L"\nSpecify an entity:", adsName, adsPoint)) {
return NULL;
}
AcDbEntity *pEntity = NULL;
AcDbObjectId idEntity = AcDbObjectId::kNull;
if (Acad::eOk != acdbGetObjectId(idEntity, adsName)) {
return NULL;
}
if (Acad::eOk != acdbOpenObject(pEntity, idEntity, mode)) {
return NULL;
}
return pEntity;
}
void printList(struct resbuf* pRb)
{
resbuf* pRbTmp = pRb;
while (pRbTmp && pRbTmp->resval.rstring) {
CLogger::Print(_T("Inform: '%s'"), pRbTmp->resval.rstring);
acutPrintf(ACRX_T("\n%s"), pRbTmp->resval.rstring);
pRbTmp = pRbTmp->rbnext;
}
}
AcApDocument* findDocument(LPCASTR pszFileName)
{
CLogger::Print(L"*Call: findDocument(%s)", pszFileName);
AcApDocument* pCurrDoc = acDocManager->curDocument();
if (pCurrDoc) {
LPCASTR pszTmp = pCurrDoc->fileName();
if (0 == lstrcmpi(pszFileName, pszTmp)) {
CLogger::Print(L"*Exit: findDocument() - Found out!");
return pCurrDoc;
}
}
AcApDocumentIterator* pDocIter = acDocManager->newAcApDocumentIterator();
for (; !pDocIter->done(); pDocIter->step()) {
AcApDocument* pDoc = pDocIter->document();
LPCASTR pszTmp = pDoc->fileName();
if (0 == lstrcmpi(pszFileName, pszTmp)) {
delete pDocIter;
CLogger::Print(L"*Exit: findDocument() - Found out!");
return pDoc;
}
}
delete pDocIter;
CLogger::Print(L"*Exit: findDocument() - Have not found out.");
return NULL;
}
int getBlockRefAll(AcDbDatabase* pDb, AcDbObjectIdArray& idaAll)
{
CLogger::Print(L"*Call: getBlockRefAll()");
if (!pDb) return 0;
Acad::ErrorStatus esResult;
idaAll.setLogicalLength(0);
CLogger::Print(L"Inform: get the block table.");
AcDbBlockTable* pBlockTable = NULL;
esResult = pDb->getBlockTable(pBlockTable, AcDb::kForRead);
if (Acad::eOk != esResult) {
CLogger::Print(L"*Exit: getBlockRefAll() - Fail to get the block table.");
return 0;
}
CLogger::Print(L"Inform: get the Model Space.");
AcDbBlockTableRecord* pModelSpace = NULL;
esResult = pBlockTable->getAt(ACDB_MODEL_SPACE, pModelSpace, AcDb::kForRead);
pBlockTable->close();
if (Acad::eOk != esResult) {
CLogger::Print(L"*Exit: getBlockRefAll() - Fail to get the model space!");
return 0;
}
CLogger::Print(L"Inform: get the Model Space Iterator.");
AcDbBlockTableRecordIterator* pRecordIter = NULL;
esResult = pModelSpace->newIterator(pRecordIter);
pModelSpace->close();
if (Acad::eOk != esResult) {
CLogger::Print(L"*Exit: getBlockRefAll() - Fail to get Model Space Iterator!");
return 0;
}
CLogger::Print(L"Inform: browse all block reference to get its ObjectId");
int nIndex = 0;
for (; !pRecordIter->done(); pRecordIter->step()) {
AcDbEntity* pEntity = NULL;
esResult = pRecordIter->getEntity(pEntity, AcDb::kForRead);
if (Acad::eOk != esResult) {
CLogger::Print(L"Warn: fail to get the entity. > Ignore");
continue;
}
if (pEntity->isKindOf(AcDbBlockReference::desc())) {
idaAll.append(pEntity->objectId());
} else {
//CLogger::Print(L"Warn: %d. the entity is not an Block Reference!", nIndex);
}
nIndex++;
pEntity->close();
}
delete pRecordIter;
CLogger::Print(L"*Exit: getBlockRefAll()");
return idaAll.length();
}
bool addToModelSpace(AcDbObjectId& idEntity, AcDbEntity* pEntity)
{
AcDbBlockTable* pBlockTable = NULL;
if (Acad::eOk != acdbHostApplicationServices()->workingDatabase()
->getSymbolTable(pBlockTable, AcDb::kForRead))
{
return false;
}
AcDbBlockTableRecord *pModelSpace = NULL;
if (Acad::eOk != pBlockTable->getAt(ACDB_MODEL_SPACE, pModelSpace, AcDb::kForWrite)) {
pBlockTable->close();
return false;
}
pBlockTable->close();
if (Acad::eOk != pModelSpace->appendAcDbEntity(idEntity, pEntity)) {
pModelSpace->close();
return false;
}
pModelSpace->close();
return true;
}
bool selectPoint(AcGePoint3d& pt3Out)
{
ads_point pnt;
if (RTNORM != acedGetPoint(NULL, L"Please specify a position.", pnt)) {
return false;
}
pt3Out = AcGePoint3d(pnt[0], pnt[1], pnt[2]);
return true;
}
| [
"quangvinh.ph@29354a60-911c-11de-8f34-01a6ee357387"
] | [
[
[
1,
234
]
]
] |
7eca40d54d6acd7f1cdacbf4b3a4a881e732898f | 3813031304899f5d0204e851cacd83717ede7159 | /examples/components/PositionComponent.h | 1cb04598218cdbd4314fe69ad84f311e48e8b80b | [] | no_license | rejacobson/noah | f631c81d059de915785bc8b02e4ab82a1dbc0147 | fb1402dfc74f4185abefe762ea6540c2dabdb694 | refs/heads/master | 2020-05-29T16:22:39.485128 | 2011-09-19T16:50:33 | 2011-09-19T16:50:33 | 2,122,220 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 977 | h | #ifndef _POSITION_COMPONENT_H
#define _POSITION_COMPONENT_H
#include <iostream>
#include <string>
#include <SFML/System.hpp>
#include <Noah/EntitySystem.h>
#include "../World.h"
class PositionComponent;
/**
* Position Component System
*/
class PositionComponentSystem : public noah::ComponentSystem <PositionComponent>
{
public:
static FamilyId family_id_;
PositionComponentSystem( void );
~PositionComponentSystem( void );
void Initialize( EntityId, GameState* );
void Update( GameState* );
};
/**
* Position Component
*/
class PositionComponent : public noah::Component <PositionComponentSystem>
{
public:
PositionComponent( void );
PositionComponent( sf::Vector2f );
PositionComponent( float, float );
void UpdatePosition( float, float );
void UpdatePosition( sf::Vector2f );
sf::Vector2f position_;
sf::Vector2f old_position_;
bool changed;
};
#endif | [
"[email protected]"
] | [
[
[
1,
50
]
]
] |
436d882305cdb694d7f63bf90b6296e6d25bffd3 | be2e23022d2eadb59a3ac3932180a1d9c9dee9c2 | /AiModule/source/AiCenter.cpp | e48202b4e4c15bd1dfcdc12ea7fe0fcfe8553d5d | [] | no_license | cronoszeu/revresyksgpr | 78fa60d375718ef789042c452cca1c77c8fa098e | 5a8f637e78f7d9e3e52acdd7abee63404de27e78 | refs/heads/master | 2020-04-16T17:33:10.793895 | 2010-06-16T12:52:45 | 2010-06-16T12:52:45 | 35,539,807 | 0 | 2 | null | null | null | null | GB18030 | C++ | false | false | 11,899 | cpp | #include "windows.h"
#include "Fact.h"
#include "SymbolTable.h"
#include "VarType.h"
#include "RuleSet.h"
#include "FactSet.h"
#include "AiCenter.h"
#include "Syntax.h"
bool IsAllWildParam(VarTypeSetRef setParam)
{
VarTypeSet::ConstIterator pParam = setParam.NewEnum();
while(pParam.Next())
{
if(!( pParam->IsSymbolType() && strcmp(static_cast<String>(*pParam), ANY_PARAM_STRING)==0 ))
return false;
}
return true;
}
bool CAiCenter::CallFunction(OBJID idFact, VarTypeSetRef setParam, ARGUMENT_SET* psetArgument)
{
switch(idFact - SYSTEM_FUNCTION_ID_BEGIN)
{
case SYS_FUNC_DUMP: // "dump", // for debug, dump this rule
{
//CHECKF(setParam.Size() == 1);
m_bDumpRule = true;
return true;
}
break;
case SYS_FUNC_KEEP: // "keep", // (int), only for change mode, keep(0) for keep fact forever
{
CHECKF(setParam.Size() == 1);
m_nNewPriority = GetValue(setParam[0], psetArgument);
return true;
}
break;
case SYS_FUNC_NOW: // "now", // (int), 当前时间
{
CHECKF(setParam.Size() == 1);
VarTypeSet setFactParam;
setFactParam.Push(Now());
return MatchParam(setFactParam, setParam, psetArgument);
}
break;
case SYS_FUNC_LESS: // "less", // (left,right), 如果 left < right 则正确
{
CHECKF(setParam.Size() == 2);
int left = GetValue(setParam[0], psetArgument);
int right = GetValue(setParam[1], psetArgument);
if(left < right)
return true;
}
break;
case SYS_FUNC_LESS_EQU: // "less_equ", // (left,right), 如果 left <= right 则正确
{
CHECKF(setParam.Size() == 2);
int left = GetValue(setParam[0], psetArgument);
int right = GetValue(setParam[1], psetArgument);
if(left <= right)
return true;
}
break;
case SYS_FUNC_STRSTR: // "strstr", // (str,substr), 如果str中包含有子串substr，正确
{
CHECKF(setParam.Size() == 2);
String left = GetValue(setParam[0], psetArgument);
String right = GetValue(setParam[1], psetArgument);
if(::StrStrCh(left, right))
return true;
}
break;
case SYS_FUNC_PERCENT: // "percent", // (int), 0 ~ 100, 有n%的机会为TRUE。
{
CHECKF(setParam.Size() == 1);
int nPercent = GetValue(setParam[0], psetArgument);
if(::RandGet(100) < nPercent)
return true;
}
break;
default:
ASSERT(!"CallFunction");
}
return false;
}
IAiCenter* IAiCenter::CreateNew()
{
return CAiCenter::CreateNew();
}
CAiCenter::CAiCenter()
{
}
CAiCenter::~CAiCenter()
{
}
bool CAiCenter::Create(IAiCenterOwner* pOwner, IDatabase* pDb, const Array<String>& setGameFunction, const Array<String>& setGameAction, int nTimeOfLife)
{
CHECKF(pOwner && pDb);
m_pOwner = pOwner;
m_nNow = nTimeOfLife;
CSymbolTable* pTable = QuerySymbolTable();
CHECKF(pTable && pTable->Create(SYSTEM_FACT_ID_BEGIN));
// sys func
OBJID idCurr = SYSTEM_FUNCTION_ID_BEGIN;
int i = 0;
while(SystemFunction(i))
{
pTable->AddSymbol(SystemFunction(i), idCurr++);
i++;
}
// game function
idCurr = GAME_FUNCTION_ID_BEGIN;
Array<String>::ConstIterator pStr = setGameFunction.NewEnum();
while(pStr.Next())
pTable->AddSymbol(*pStr, idCurr++);
// game action
idCurr = GAME_ACTION_ID_BEGIN;
pStr = setGameAction.NewEnum();
while(pStr.Next())
pTable->AddSymbol(*pStr, idCurr++);
if(!m_pFactSet->Create(this, pDb, nTimeOfLife))
return false;
if(!m_pRuleSet->Create(this, pDb, m_nNow))
return false;
return true;
}
void CAiCenter::Thinking(int nStep)
{
CRuleSet::Iterator pRule = m_pRuleSet->NewEnum();
while(pRule.Next())
{
if(pRule->ToNextTime(Now()))
{
DEBUG_TRY /////////////////////
// LOGDUMP("Process Rule %u: ", pRule->GetID());
ProcessRule(pRule);
DEBUG_CATCH2("Process Rule %u", pRule->GetID()) ///////////////////////
}
// if(--nStep <= 0)
// return;
}
}
void CAiCenter::OnTimer()
{
DEBUG_TRY /////////////////////
Thinking(10000);
// clear
m_nNow++;
ClearInvalidRule();
DEBUG_CATCH("CAiCenter::OnTimer()") ///////////////////////
}
void CAiCenter::AddFact(StringRef strFact, int nPriority)
{
m_pFactSet->AddFact(strFact, nPriority, Now(), m_pOwner->Priority2Durable(nPriority));
}
bool CAiCenter::ProcessRule(const CRuleObj* pRule)
{
CFactRef cMode = pRule->GetMode();
m_bDumpRule = false;
m_nNewPriority = PRIORITY_NONE;
ARGUMENT_SET setArgument;
if(!ProcessRuleNest(cMode.IsLogicNot(), cMode.GetType(), cMode.GetParamSet(), setArgument, pRule, pRule->GetCondition().NewEnum()))
{
m_pFactSet->CombineQueue();
if(m_bDumpRule)
LOGDUMP("--- failed ---");
return false;
}
m_pFactSet->CombineQueue();
LOGDUMP("process rule ok: %u", pRule->GetID());
return true;
}
bool CAiCenter::ProcessRuleNest(bool bLogicNot, OBJID idFact, VarTypeSetRef setParam, ARGUMENT_SET& setArgument, const CRuleObj* pRule, CFactArray::ConstIterator iterFact)
{
#ifdef DUMP_DEBUG_MSG
String strFact;
strFact += bLogicNot?String("!"):String();
strFact += m_pFactSet->QuerySymbolTable()->FindSymbolByID(idFact);
strFact += setParam.Dump();
String strDumpArgu = setArgument.Dump();
String strDumpRule = pRule->Dump();
#endif
if(m_bDumpRule)
LOGDUMP("*** system function: %c %s,%s - %s", bLogicNot?'!':' ', m_pSymbolTable->FindSymbolByID(idFact), (LPCTSTR)::DumpString(setParam), (LPCTSTR)setArgument.Dump());
// check function implement by ai module
if(IsFunction(idFact))
{
if((bLogicNot==0) == (CallFunction(idFact, setParam, &setArgument)!=0))
{
if(iterFact.Next())
return ProcessRuleNest(iterFact->IsLogicNot(), iterFact->GetType(), iterFact->GetParamSet(), setArgument, pRule, iterFact); // nest call self
else
return ProcessResult(pRule->GetResult(), pRule->GetPattern(), pRule->GetPriority(), setArgument);
}
return false;
}
// check fact function implement by game kernel
if(IsFactFunction(idFact))
{
int idxFactFunction = idFact - GAME_FUNCTION_ID_BEGIN;
if(m_pOwner->CheckCondition(bLogicNot, idxFactFunction, setParam, &setArgument))
{
if(iterFact.Next())
return ProcessRuleNest(iterFact->IsLogicNot(), iterFact->GetType(), iterFact->GetParamSet(), setArgument, pRule, iterFact); // nest call self
else
return ProcessResult(pRule->GetResult(), pRule->GetPattern(), pRule->GetPriority(), setArgument);
}
return false;
}
// collect facts
bool bWildParam = IsAllWildParam(setParam);
CFactArray setFacts;
CFactSet::Iterator pFact = m_pFactSet->NewEnum();
while(pFact.Next())
{
ARGUMENT_SET setArg = setArgument;
if(pFact->GetType() == idFact)
{
ASSERT(pFact->IsAlive(Now()));
#ifdef DUMP_DEBUG_MSG
String strSet1 = ::DumpString(pFact->GetParamSet());
String strSet2 = ::DumpString(setParam);
#endif
if(IAiCenter::MatchParam(pFact->GetParamSet(), setParam, &setArg))
{
if(!bLogicNot)
{
setFacts.Push(pFact->QueryFact());
if(bWildParam)
break;
}
else
{
return false;
}
}
}
} // while all fact
// check facts
bool bNext = iterFact.Next();
if(!bLogicNot && setFacts.Size())
{
bool ret = false;
CFactArray::Iterator pFact = setFacts.NewEnum();
while(pFact.Next())
{
ARGUMENT_SET setArg = setArgument;
ASSERT(IAiCenter::MatchParam(pFact->GetParamSet(), setParam, &setArg));
if(bNext)
ret |= ProcessRuleNest(iterFact->IsLogicNot(), iterFact->GetType(), iterFact->GetParamSet(), setArg, pRule, iterFact); // nest call self
else
ret |= ProcessResult(pRule->GetResult(), pRule->GetPattern(), pRule->GetPriority(), setArg);
if(bWildParam)
break;
}
return ret;
}
else if(bLogicNot && setFacts.Size()==0)
{
if(bNext)
return ProcessRuleNest(iterFact->IsLogicNot(), iterFact->GetType(), iterFact->GetParamSet(), setArgument, pRule, iterFact); // nest call self
else
return ProcessResult(pRule->GetResult(), pRule->GetPattern(), pRule->GetPriority(), setArgument);
}
return false;
}
VarTypeRef IAiCenter::GetValue(VarTypeRef cParam, ARGUMENT_SET* psetArgument)
{
if(cParam.IsSymbolType())
{
IF_OK(psetArgument->IsIn(cParam))
{
return (*psetArgument)[cParam];
}
}
ASSERT(!cParam.IsSymbolType());
return cParam;
}
bool IAiCenter::MatchParam(VarTypeSetRef setFactParam, VarTypeSetRef setRuleParam, ARGUMENT_SET* psetArgument)
{
// check fact param set
VarTypeSet::ConstIterator pFactParam = setFactParam.NewEnum();
VarTypeSet::ConstIterator pRuleArg = setRuleParam.NewEnum();
while(pFactParam.Next())
{
CHECKF(pRuleArg.Next());
if(*pFactParam == *pRuleArg)
continue;
else if(!pRuleArg->IsSymbolType())
{
return false;
}
else // if(pRuleArg->IsSymbolType())
{
if(static_cast<String>(*pRuleArg) == static_cast<String>(ANY_PARAM_STRING))
continue;
else if(!psetArgument->IsIn(*pRuleArg))
{
psetArgument->Add(static_cast<String>(*pRuleArg), *pFactParam);
}
else // if(psetArgument->IsIn(*pRuleArg))
{
if(*pFactParam != (*psetArgument)[*pRuleArg])
{
return false;
}
}
}
} // while param list
return true;
}
bool CAiCenter::ProcessResult(CFactRef cResult, CFactRef cPattern, int nPriority, ARGUMENT_SET_REF setArgument)
{
if(m_bDumpRule)
LOGDUMP("=== success result: %s - %s", (LPCTSTR)::DumpString(cResult), (LPCTSTR)::DumpString(cPattern));
if(m_nNewPriority != PRIORITY_NONE)
{
nPriority = m_nNewPriority;
LOGDUMP("Change Mode: %s ===========================================", (LPCTSTR)::DumpString(cResult));
}
CHECKF(cPattern.IsLogicNot());
CFact cNewPattern = cPattern;
::ReplaceSymbol(&cNewPattern, setArgument);
m_pFactSet->AddFactQueue(cNewPattern, nPriority, Now(), m_pOwner->Priority2Durable(nPriority));
// action
if(IsAction(cNewPattern.GetType()))
ClearAlikeAction(cNewPattern);
if(!cResult.IsLogicNot())
{
CFact cNewFact = cResult;
::ReplaceSymbol(&cNewFact, setArgument);
m_pFactSet->AddFactQueue(cNewFact, nPriority, Now(), m_pOwner->Priority2Durable(nPriority));
// action
if(IsAction(cNewFact.GetType()))
{
m_setAction.Push(cNewFact);
LOGDUMP("push action: %s", (const char*)cNewFact.Dump(), nPriority, Now());
}
}
return true;
}
bool IsLikeModel(CFactRef cFact, CFactRef cPattern)
{
if(cPattern.GetType() != cFact.GetType())
return false;
if(cPattern.GetParamSet().Size() != cFact.GetParamSet().Size())
return false;
for(int i = 0; i < cFact.GetParamSet().Size(); i++)
{
VarTypeRef obj = cPattern.GetParamSet().At(i);
if(obj.IsValid())
{
if(obj != cFact.GetParamSet().At(i))
return false;
}
}
return true;
}
void CAiCenter::ClearAlikeAction(CFactRef cPattern)
{
CFactArray::Iterator pFact = m_setAction.NewEnum();
while(pFact.Next())
{
if(IsLikeModel(*pFact, cPattern))
{
LOGDUMP("Del Alike Action: %s", (const char*)pFact->Dump());
m_setAction.DelObj(pFact);
}
}
}
bool CAiCenter::FetchAction(int* pidxAction, VarTypeSet* psetParam)
{
CFactArray::Iterator pAction = m_setAction.NewEnum();
if(pAction.Next())
{
*pidxAction = pAction->GetType() - GAME_ACTION_ID_BEGIN;
*psetParam = pAction->GetParamSet();
LOGDUMP("Agent FetchAction type: %u", pAction->GetType());
m_setAction.DelObj(pAction);
return true;
}
return false;
}
void CAiCenter::Persistent(IDatabase* pDb) { m_pFactSet->Persistent(pDb, Now()); }
void CAiCenter::ClearInvalidRule()
{
CFactSet::Iterator pFact = m_pFactSet->NewEnum();
while(pFact.Next())
{
if(!pFact->IsAlive(Now()))
{
LOGDUMP("Clear fact: %s, Now:%d", (LPCTSTR)(pFact->Dump()), Now());
m_pFactSet->DelObj(pFact);
}
}
}
| [
"rpgsky.com@cc92e6ba-efcf-11de-bf31-4dec8810c1c1"
] | [
[
[
1,
451
]
]
] |
830a7ee735a0618a531e18433ed61353aa94cb70 | 906e87b1936397339734770be45317f06fe66e6e | /include/TGImageButton.h | 9076cecffcc6cfc5502fa65b527c65c9edcc37ac | [] | no_license | kcmohanprasad/tgui | 03c1ab47e9058bc763b7e6ffc21a37b4358369bf | 9f9cf391fa86b99c7d606c4d196e512a7b06be95 | refs/heads/master | 2021-01-10T08:52:18.629088 | 2007-05-17T04:42:58 | 2007-05-17T04:42:58 | 52,069,498 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,165 | h | //-----------------------------------------------------------------------------
// This source file is part of TGUI (Tiny GUI)
//
// Copyright (c) 2006-2007 Tubras Software, Ltd
// Also see acknowledgements in Readme.html
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
// of the Software, and to permit persons to whom the Software is furnished to
// do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//-----------------------------------------------------------------------------
#ifndef __TGIMAGEBUTTON_H__
#define __TGIMAGEBUTTON_H__
namespace TGUI
{
class _TGUIExport TGImageButton : public TGControl
{
TGImageSet* m_images;
bool m_pushed;
bool m_highlighted;
int m_uvIndex;
public:
TGImageButton(TGControl *parent, TGString name, TGString imageName, TGString resourceGroup="");
virtual ~TGImageButton();
virtual void render();
virtual TGString getControlType() {return "TGImageButton";}
virtual void onMouseDown(int x, int y, int b);
virtual void onMouseUp(int x, int y, int b);
virtual void onMouseEnter();
virtual void onMouseExit(int x, int y);
};
}
#endif
| [
"pc0der@a5263bde-0223-0410-8bbb-1954fdd97a2f"
] | [
[
[
1,
52
]
]
] |
c13f6ce8d2ba326ea4b7d3a792326ba3ac209f5e | ed9ecdcba4932c1adacac9218c83e19f71695658 | /PhysicsDemo2/PhysicsDemo2/particleforcegenerator.cpp | b30ad4564f6bb6712741cc96a7d7e29417d0a9c8 | [] | no_license | karansapra/futurattack | 59cc71d2cc6564a066a8e2f18e2edfc140f7c4ab | 81e46a33ec58b258161f0dd71757a499263aaa62 | refs/heads/master | 2021-01-10T08:47:01.902600 | 2010-09-20T20:25:04 | 2010-09-20T20:25:04 | 45,804,375 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,671 | cpp | #include "particleforcegenerator.h"
void ParticleForceRegistry::Add(Particle * particle, ParticleForceGenerator * fg)
{
ParticleForceRegistration pfr;
pfr.fg = fg;
pfr.p = particle;
registrations.push_back(pfr);
}
void ParticleForceRegistry::Clear()
{
registrations.clear();
}
void ParticleForceRegistry::UpdateForce(REAL dt)
{
Registry::iterator i;
for (i=registrations.begin();i!=registrations.end();i++)
i->fg->UpdateForce(i->p,dt);
}
ParticleGravity::ParticleGravity()
{
}
ParticleGravity::ParticleGravity(const Vector3 & g)
{
gravity = g;
}
void ParticleGravity::UpdateForce(Particle * p, REAL dt)
{
if (p->HasInfiniteMass())
return;
p->AddForce(gravity*p->GetMass());
}
ParticleSpring::ParticleSpring(Particle * other_particle)
{
other = other_particle;
spring_constant = 1.0;
spring_length = 10.0;
}
void ParticleSpring::UpdateForce(Particle * p, REAL dt)
{
Vector3 force = p->position - other->position;
REAL mag = force.Length();
mag = abs_real(mag-spring_length);
mag *= spring_constant;
force.Normalize();
force *= -mag;
p->AddForce(force);
}
ParticleAnchoredSpring::ParticleAnchoredSpring()
{
spring_constant = 1.0;
spring_length = 10.0;
}
ParticleAnchoredSpring::ParticleAnchoredSpring(Vector3 & anchor_point)
{
anchor = anchor_point;
spring_constant = 1.0;
spring_length = 10.0;
}
void ParticleAnchoredSpring::UpdateForce(Particle * p, REAL dt)
{
Vector3 force = p->position - anchor;
REAL mag = force.Length();
mag = abs_real(mag-spring_length);
mag *= spring_constant;
force.Normalize();
force *= -mag;
p->AddForce(force);
} | [
"clems71@52ecbd26-af3e-11de-a2ab-0da4ed5138bb"
] | [
[
[
1,
82
]
]
] |
44ffa2e7d9826adaa032859d375bd2b1cb4d3fd0 | 36bf908bb8423598bda91bd63c4bcbc02db67a9d | /Library/strcpyn.cpp | a3e6b3b77aeb254dd8865a4eae93ef8988d07548 | [] | no_license | code4bones/crawlpaper | edbae18a8b099814a1eed5453607a2d66142b496 | f218be1947a9791b2438b438362bc66c0a505f99 | refs/heads/master | 2021-01-10T13:11:23.176481 | 2011-04-14T11:04:17 | 2011-04-14T11:04:17 | 44,686,513 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 549 | cpp | /*
strcpyn.cpp
Copia con controllo sulla dimensione.
Luca Piergentili, 15/05/98
[email protected]
*/
#include "env.h"
#include "pragma.h"
#include <string.h>
#include "strcpyn.h"
/*
strcpyn()
Passare sizeof, copia sizeof - 1:
char s[n+1];
char* p = "...";
strcpyn(s,p,n+1); -> s[n+1] = 0
*/
char* strcpyn(char* s1,const char *s2,int size)
{
if(!s1)
return(NULL);
if(!s2 || !*s2)
{
memset(s1,'\0',size);
return(NULL);
}
char* p = strncpy(s1,s2,size);
s1[size-1] = '\0';
return(p);
}
| [
"[email protected]"
] | [
[
[
1,
35
]
]
] |
72812f3b3e59d7226ed36ab08d9d128a4fbe8742 | fbd2deaa66c52fc8c38baa90dd8f662aabf1f0dd | /totalFirePower/TotalFirepower/src/ccUnit.cpp | 8fdcd1f116ed205d02417e1736c4106dabe8433c | [] | no_license | arlukin/dev | ea4f62f3a2f95e1bd451fb446409ab33e5c0d6e1 | b71fa9e9d8953e33f25c2ae7e5b3c8e0defd18e0 | refs/heads/master | 2021-01-15T11:29:03.247836 | 2011-02-24T23:27:03 | 2011-02-24T23:27:03 | 1,408,455 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,621 | cpp | // ccUnit.cpp: implementation of the ccUnit class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ccTileMap.h"
#include "cc3do.h"
#include "ccUnit.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
ccUnit::ccUnit(ccTileMap * tileMap, ccArrayList * unitList)
{
m_pUnitImage = NULL;
m_3do = new cc3do;
m_tileMap = tileMap;
m_unitList = unitList;
m_position.x = 0;
m_position.y = 0;
m_unitSize.cx = m_unitSize.cy = 0;
m_unitRect.left = m_unitRect.top = 0;
m_unitRect.right = m_unitRect.bottom = 0;
m_speed = 1;
max_speed = 10;
m_yaw = 0;
m_pitch = 0;
m_roll = 0;
}
ccUnit::~ccUnit()
{
SAFE_DELETE(m_3do);
}
//
void ccUnit::rotate(float yaw, float pitch, float roll)
{
m_yaw += yaw;
m_pitch += pitch;
m_roll += roll;
}
POINT * ccUnit::getWorldPosition()
{
return &m_position;
}
void ccUnit::movePosition(int x, int y)
{
RECT unitRect;
unitRect.left = m_position.x + x*m_speed;
unitRect.top = m_position.y + y*m_speed;
unitRect.right = unitRect.left + m_unitSize.cx;
unitRect.bottom = unitRect.top + m_unitSize.cy;
if (SUCCEEDED(validRect(&unitRect)))
{
m_position.x = unitRect.left;
m_position.y = unitRect.top;
m_unitRect = unitRect;
}
}
void ccUnit::setPosition(int x, int y)
{
RECT unitRect;
unitRect.left = x;
unitRect.top = y;
unitRect.right = unitRect.left + m_unitSize.cx;
unitRect.bottom = unitRect.top + m_unitSize.cy;
if (SUCCEEDED(validRect(&unitRect)))
{
m_position.x =unitRect.left;
m_position.y =unitRect.top;
m_unitRect = unitRect;
}
}
HRESULT ccUnit::validRect(RECT * unitRect)
{
HRESULT hr = S_OK;
if (m_tileMap)
{
// FIX: Kanske flytta till ccTileMap. ValidWorldPosition()
//
// validMapPostion
//
SIZE * mapWorldSize = m_tileMap->getWorldSize();
if (unitRect->left < 0)
unitRect->left = 0;
else if (unitRect->left > (mapWorldSize->cx-m_unitSize.cx))
unitRect->left = (mapWorldSize->cx-m_unitSize.cx);
if (unitRect->top < 0)
unitRect->top = 0;
else if (unitRect->top > (mapWorldSize->cy-m_unitSize.cy))
unitRect->top = (mapWorldSize->cy-m_unitSize.cy);
//
// Collision With Other Unit?
//
ccUnit *unit;
for(int i=0;i<m_unitList->count();i++)
{
unit = (ccUnit*)(*m_unitList)[i];
if (this != unit)
{
if (FAILED(unit->isCollision(unitRect)))
{
hr = E_FAIL;
}
}
}
}
else
{
m_position.x = m_position.y = 0;
hr = E_FAIL;
}
return hr;
}
//
//-----------------------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: Initializes device-dependent objects, including the vertex buffer used
// for rendering text and the texture map which stores the font image.
//-----------------------------------------------------------------------------
HRESULT ccUnit::InitDeviceObjects(LPDIRECT3DDEVICE9 pd3dDevice)
{
m_3do->InitDeviceObjects(pd3dDevice);
// Keep a local copy of the device
m_pd3dDevice = pd3dDevice;
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc:
//-----------------------------------------------------------------------------
HRESULT ccUnit::RestoreDeviceObjects()
{
HRESULT hr = S_OK;
if (FAILED(m_3do->RestoreDeviceObjects()))
return hr;
if (FAILED(hr=loadUnit()))
return hr;
return hr;
}
//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT ccUnit::InvalidateDeviceObjects()
{
m_3do->InvalidateDeviceObjects();
SAFE_RELEASE(m_pUnitImage);
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: DeleteDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT ccUnit::DeleteDeviceObjects()
{
m_3do->DeleteDeviceObjects();
m_pd3dDevice = NULL;
return S_OK;
}
// draw2DUnit
HRESULT ccUnit::drawUnit()
{
m_3do->draw((float)m_position.x, (float)m_position.y, 0, m_yaw, m_pitch, m_roll);
return S_OK;
if( m_pd3dDevice == NULL )
return E_FAIL;
HRESULT hr;
IDirect3DSurface9 *ppBackBuffer;
if (SUCCEEDED(hr = m_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &ppBackBuffer)))
{
RECT srcRect, destRect;
destRect.left = m_position.x;
destRect.top = m_position.y;
destRect.right = m_position.x+m_unitSize.cx;
destRect.bottom = m_position.y+m_unitSize.cy;
srcRect.left = srcRect.top = 0;
srcRect.right = m_unitSize.cx;
srcRect.bottom = m_unitSize.cy;
if (SUCCEEDED(m_tileMap->worldToScreenPos(&destRect, &srcRect)))
{
hr = m_pd3dDevice->StretchRect(m_pUnitImage, &srcRect, ppBackBuffer, &destRect, D3DTEXF_NONE);
}
}
SAFE_RELEASE(ppBackBuffer);
return hr;
}
//
HRESULT ccUnit::loadUnit()
{
//
// Create surfaces.
//
HRESULT hr;
IDirect3DSurface9 *ppBackBuffer;
if (SUCCEEDED(hr = m_pd3dDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &ppBackBuffer)))
{
D3DSURFACE_DESC d3dsDesc;
ppBackBuffer->GetDesc(&d3dsDesc);
char fileName[] = "..//units//armbulldog.bmp";
if (FAILED(hr = D3DXGetImageInfoFromFile(
fileName,
&m_srcInfo)))
return hr;
m_unitSize.cx = m_srcInfo.Width;
m_unitSize.cy = m_srcInfo.Height;
m_unitRect.right += m_unitSize.cx;
m_unitRect.bottom += m_unitSize.cy;
if (FAILED(hr = m_pd3dDevice->CreateOffscreenPlainSurface(
m_srcInfo.Width, m_srcInfo.Height, d3dsDesc.Format, D3DPOOL_DEFAULT, &m_pUnitImage, NULL)))
return hr;
if (FAILED(hr = D3DXLoadSurfaceFromFile(
m_pUnitImage,
NULL,
NULL,
fileName,
NULL,
D3DX_FILTER_NONE,
0x7B97FF,
&m_srcInfo
)))
return hr;
}
SAFE_RELEASE(ppBackBuffer);
return S_OK;
}
HRESULT ccUnit::isCollision(RECT *unitRect)
{
if (
m_unitRect.left < unitRect->right && m_unitRect.top < unitRect->bottom &&
m_unitRect.right > unitRect->left && m_unitRect.bottom > unitRect->top
)
return E_FAIL;
else
return S_OK;
}
| [
"[email protected]"
] | [
[
[
1,
289
]
]
] |
f9d7eeae408d404c6c7967bbdf0d0c05432089a4 | cb0268e95542374ff2abf2b9c770d1c106774624 | /modelLoader/MD2Mesh.cpp | d5c8ae94fab4e832c4f58a554e6dcb8011ad7942 | [] | no_license | xXSingularityXx/Bomber-Rage-3D | a898e046cf93649a052d5c1ad019cc60dd5184ce | 7249c95055ca5df6c05775f8006f307dab5cc856 | refs/heads/master | 2021-01-10T21:20:31.343120 | 2009-12-17T07:54:42 | 2009-12-17T07:54:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,190 | cpp |
#include "MD2Mesh.h"
MD2::MD2Mesh::MD2Mesh()
{
m_time=0;
//m_frameInfo.startFrame = 0;
//m_frameInfo.endFrame = m_header.num_frames-1;
}
MD2::MD2Mesh::~MD2Mesh()
{
delete [] m_tris;
delete [] m_texCoord;
delete [] m_frames;
delete [] m_glcmds;
}
void MD2::MD2Mesh::loadMD2(std::string _path)
{
//open the MD2 file
std::ifstream file;
file.open(_path.c_str(), std::ios::binary);
if (file.fail())
return;
//read the header of the file
file.read (reinterpret_cast<char *>(&m_header), sizeof (MD2::Header));
// Check if identification and version are valid
if (m_header.ident != MD2::MD2_IDENT)
{
file.close();
return;
}
if (m_header.version != MD2::MD2_VERSION)
{
file.close();
return;
}
// Memory allocation for model data
//_skins = new Md2Skin_t[_header.num_skins];
m_texCoord = new MD2::TexCoord[m_header.num_st];
m_tris = new MD2::Triangle[m_header.num_tris];
m_frames = new MD2::Frame[m_header.num_frames];
m_glcmds = new int[m_header.num_glcmds];
// Read texture coords.
file.seekg (m_header.ofs_st, std::ios::beg);
file.read (reinterpret_cast<char *>(m_texCoord), sizeof (MD2::TexCoord) * m_header.num_st);
// Read triangle data
file.seekg (m_header.ofs_tris, std::ios::beg);
file.read (reinterpret_cast<char *>(m_tris), sizeof(MD2::Triangle) * m_header.num_tris);
// Read frames
file.seekg (m_header.ofs_frames, std::ios::beg);
for (int i = 0; i < m_header.num_frames; ++i)
{
// Memory allocation for the vertices of this frame
m_frames[i].verts = new MD2::VertexCoord[m_header.num_xyz];
// Read frame data: scale, translate, name of animation and array of vertices
file.read (reinterpret_cast<char *>(&m_frames[i].scale), sizeof (float)*3);
file.read (reinterpret_cast<char *>(&m_frames[i].translate), sizeof (float)*3);
file.read (reinterpret_cast<char *>(&m_frames[i].name), sizeof (char) * 16);
file.read (reinterpret_cast<char *>(m_frames[i].verts), sizeof (MD2::VertexCoord) * m_header.num_xyz);
}
// Read OpenGL commands
file.seekg (m_header.ofs_glcmds, std::ios::beg);
file.read (reinterpret_cast<char *>(m_glcmds), sizeof (int) * m_header.num_glcmds);
file.close();
setupAnimation();
}
void MD2::MD2Mesh::setupAnimation()
{
std::string currentAnim;
MD2::AnimInfo animInfo = { 0, 0 };
for (int i = 0; i < m_header.num_frames; ++i)
{
std::string frameName = m_frames[i].name;
std::string frameAnim;
// Extract animation name from frame name
std::string::size_type len = frameName.find_first_of ("0123456789");
if ((len == frameName.length () - 3) && (frameName[len] != '0'))
len++;
frameAnim.assign (frameName, 0, len);
if (!currentAnim.compare(frameAnim) == 0)
{
if (i > 0)
{
// Previous animation is finished, insert
// it and start new animation.
m_anims.insert (AnimMap::value_type
(currentAnim, animInfo));
}
// Initialize new anim info
animInfo.startFrame = i;
animInfo.endFrame = i;
currentAnim = frameAnim;
}
else
{
animInfo.endFrame = i;
}
}
// Insert last animation
m_anims.insert (AnimMap::value_type (currentAnim, animInfo));
} | [
"Samuel@matschulat.(none)"
] | [
[
[
1,
123
]
]
] |
274da51b8f0d4f723af6cce4f58e581373effb13 | d99132589576273af2c53da2b2e9376399a7c6b7 | /source/pid.cpp | b208e1e9c1102d56e86de2118e848a54803040a2 | [] | no_license | ee-444/trimmed_RoverMission | c71cfa6e69556e513b90ba896185f4748fb4beb0 | 04e41b43d285c8da099a5773a0e009e8332abb39 | refs/heads/master | 2021-01-23T00:15:34.434778 | 2011-05-17T23:53:04 | 2011-05-17T23:53:04 | 1,762,413 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,986 | cpp |
//PID control code by Tim Hirzel
//modified by Misael Espinoza
//This module implements a PID control loop initializes it with 3 values: p, i, d
//and then tunes the feedback loop with the setP, setI, setD functions
#include "pid.h"
unsigned int timeCount = 0;
// variables used in asjustment
float iState = 0;
float lastHeading = 0;
float pTerm, iTerm, dTerm;
// constants used in adjustment
const float pgain = 0.9;
const float igain = 0.01;
const float dgain = 1.0;
const float WINDUP_GUARD_GAIN = 100.0;
float updatePID(float targetHeading, float curHeading)
{
double result;
float error;
float windupGuard;
//determine error
error = targetHeading - curHeading;
//limit rotation
if(error > 1800){
error -= 3600;
}
else if (error < -1800){
error += 3600;
}
/*---------------PROPORTIONAL---------------*/
//the pTerm is the present, it is the instantaneous error
pTerm = pgain * error;
/*---------------PROPORTIONAL---------------*/
/*---------------INTEGRAL---------------*/
//iState is the past, it is the accumulated error over time
iState += error;
//Windup guard, if the robot is turned completely around, this prevents
//it from not being able to correct itself
//make windup guard values relative to current iGain
windupGuard = WINDUP_GUARD_GAIN / igain;
if(iState > windupGuard){//protects against excessive positive error
iState = windupGuard;
}
else if(iState < -windupGuard){//protects against excessive negative error
iState = -windupGuard;
}
//accumulated error multiplied by the gain determine the iTerm
iTerm = igain * iState;
/*---------------INTEGRAL---------------*/
/*---------------DERIVATIVE---------------*/
//The dTerm is the future, it is the rate at which the heading is changing
dTerm = (dgain * (curHeading - lastHeading));
//store the current temperature
lastHeading = curHeading;
//feedback
return pTerm + iTerm - dTerm;
}
| [
"[email protected]"
] | [
[
[
1,
73
]
]
] |
8b4ca1c598c4c9971ab58bb3e3b69dfa96e44599 | 0b66a94448cb545504692eafa3a32f435cdf92fa | /tags/0.6/cbear.berlios.de/windows/mutex.hpp | d585b5929f5ebea10a37a81e17b7b60c501a53f7 | [
"MIT"
] | permissive | BackupTheBerlios/cbear-svn | e6629dfa5175776fbc41510e2f46ff4ff4280f08 | 0109296039b505d71dc215a0b256f73b1a60b3af | refs/heads/master | 2021-03-12T22:51:43.491728 | 2007-09-28T01:13:48 | 2007-09-28T01:13:48 | 40,608,034 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,057 | hpp | /*
The MIT License
Copyright (c) 2005 C Bear (http://cbear.berlios.de)
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef CBEAR_BERLIOS_DE_WINDOWS_MUTEX_HPP_INCLUDED
#define CBEAR_BERLIOS_DE_WINDOWS_MUTEX_HPP_INCLUDED
#include <cbear.berlios.de/windows/base.hpp>
#include <cbear.berlios.de/windows/bool.hpp>
#include <cbear.berlios.de/windows/exception.hpp>
#include <cbear.berlios.de/windows/select.hpp>
#include <cbear.berlios.de/windows/handle.hpp>
#include <cbear.berlios.de/windows/lpstr.hpp>
#include <cbear.berlios.de/windows/security_attributes.hpp>
namespace cbear_berlios_de
{
namespace windows
{
// The function creates or opens a named or unnamed mutex object.
template<class Char>
handle create_mutex(
security_attributes MutexAttributes,
bool_t InitialOwner,
const basic_lpstr<const Char> &Name)
{
exception::scope_last_error ScopeLastError;
return handle(CBEAR_BERLIOS_DE_WINDOWS_FUNCTION(Char, ::CreateMutex)(
MutexAttributes.get(), InitialOwner.get(), Name.get()));
}
}
}
#endif
| [
"sergey_shandar@e6e9985e-9100-0410-869a-e199dc1b6838"
] | [
[
[
1,
54
]
]
] |
f9ca202bf6a499d738fbcccf861b6e2357c5142a | 8624913a6962fcfefe493d082783e66e8edcb9b1 | /teacherType.h | 99776f3eda465c8753f8aa576dfee8e6dc46a404 | [] | no_license | s00pcan/Term-project-for-CS322 | bf336f6d024a49da7982e418f8b9bf7a8a37198e | a7917c2f99074121c32a79987f6167d7f21a450e | refs/heads/master | 2020-12-30T10:23:36.724990 | 2011-02-16T21:24:00 | 2011-02-16T21:24:00 | 1,357,223 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 656 | h | // include teacherType header file if not defined
#ifndef H_teacherType
#define H_teacherType
#include <string> // needed for string use
#include <vector> // needed for vector use
using namespace std; // allow use of standard namespace
/*** definition of teacherType class ***/
class teacherType
{
public:
void setTeacher(int id, string first, string last, string email,int phone);
void getTeacher(int& id, string& first, string& last, string& email,int& phone);
protected:
int tchid;
string firstName; // stores the first name
string lastName; // stores the last name
string tchemail;
int tchphone;
};
#endif | [
"[email protected]"
] | [
[
[
1,
24
]
]
] |
170940a685f02cda97daae454563bbf183aa955b | 335783c9e5837a1b626073d1288b492f9f6b057f | /source/fbxcmd/daolib/Model/Common/quaternion.h | 970fe262b461f36f4c58b87874b7de0656c1a750 | [
"BSD-3-Clause",
"LicenseRef-scancode-warranty-disclaimer",
"BSD-2-Clause"
] | permissive | code-google-com/fbx4eclipse | 110766ee9760029d5017536847e9f3dc09e6ebd2 | cc494db4261d7d636f8c4d0313db3953b781e295 | refs/heads/master | 2016-09-08T01:55:57.195874 | 2009-12-03T20:35:48 | 2009-12-03T20:35:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,631 | h | #pragma once
class Matrix33;
class Matrix43;
class Matrix44;
class Quaternion
{
public:
float x,y,z,w;
// Constructors
Quaternion(): x(0.0f),y(0.0f),z(0.0f),w(1.0f) {}
Quaternion(float X, float Y, float Z, float W) { x = X; y = Y; z = Z; w = W; }
Quaternion(double X, double Y, double Z, double W) {
x = (float)X; y = (float)Y; z = (float)Z; w = (float)W;
}
Quaternion(const Quaternion& a) { x = a.x; y = a.y; z = a.z; w = a.w; }
Quaternion(float af[4]) { x = af[0]; y = af[1]; z = af[2]; w = af[3]; }
// Access operators
float& operator[](int i) { return (&x)[i]; }
const float& operator[](int i) const { return (&x)[i]; }
float Scalar() { return w; }
Vector3f Vector() { return Vector3f(x, y, z); }
// Conversion function
operator float*() { return(&x); }
// Unary operators
Quaternion operator-() const { return(Quaternion(-x,-y,-z,-w)); }
Quaternion operator+() const { return *this; }
Quaternion& Set(float X, float Y, float Z, float W)
{ x = X; y = Y; z = Z; w = W; return *this; }
Quaternion& Set(double X, double Y, double Z, double W)
{ x = (float)X; y = (float)Y; z = (float)Z; w = (float)W;
return *this; }
Quaternion& Set(const Vector3f& V, float W)
{ x = V.x; y = V.y; z = V.z; w = W; return *this; }
void Identity() { x = y = z = (float)0.0; w = (float) 1.0; }
void MakeMatrix(Matrix33& m) const;
void MakeMatrix(Matrix43& m) const;
void MakeMatrix(Matrix44& m) const;
Vector3f AsEulerYawPitchRoll() const;
Quaternion Quaternion::Inverse() const {
return Quaternion(-x, -y, -z, w);
}
};
| [
"tazpn314@ccf8930c-dfc1-11de-9043-17b7bd24f792"
] | [
[
[
1,
55
]
]
] |
d05c7805b89bb08994124bdb2c929a6ce33c7d05 | aac249804785b4e1cd03ff0ac46ac3c574f65598 | /systrayicon.hxx | f1e08c0234903b68b6f7ddb4089984d41b2fa9ef | [] | no_license | coolboy/qclipper | 16392656fb0e74f07fa7a0530a5425aae5f569d9 | 4276ee471d3554bb966b70c58fd865484c9505bc | refs/heads/master | 2021-01-19T13:32:03.338445 | 2010-01-01T21:08:44 | 2010-01-01T21:08:44 | 32,131,692 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,099 | hxx | /*
* Copyright (c) 2010, Sysu
* 保留所有权利。( All rights reserved. )
*
* 文件名称：systrayicon.hxx
* 文件标识：
* 摘 要：
*
* 当前版本：1.0
* 作 者：Coolboy
* 完成日期：2010年1月1日
*
* 取代版本：
* 原作者 ：
* 完成日期：
*/
#pragma once
#include <QSystemTrayIcon>
#include <QQueue>
class QAction;
class QSystemTrayIcon;
class SystrayIcon : public QSystemTrayIcon
{
Q_OBJECT
public:
SystrayIcon( QObject * parent = 0 );//SystrayIcon(QWidget *parent = 0);
~SystrayIcon();
private slots:
void constructSystrayMenu();
void clipTextClicked(int);
void systrayClicked(QSystemTrayIcon::ActivationReason);
void showAbout();
void showConfigDialog();
private:
QString getDisplayText(QString);
void saveSettings();
QStringList strLst;
QMenu *trayIconMenu;
QAction *quitAction;
QAction *configureAction;
QAction *aboutAction;
QString history_file_name;
int history_max_size;
int entry_display_max_size;
bool clipboard_history_save;
};
| [
"coolcute@7ce5298a-f695-11de-a831-516a40b15b2e"
] | [
[
[
1,
53
]
]
] |
012a47a3ad0b264db1a7acbcd95a7ff0b9f27f2e | 91b964984762870246a2a71cb32187eb9e85d74e | /SRC/OFFI SRC!/_Common/InstanceDungeonBase.h | 3a59b5bbea2388549371614569eaaa37218d5f08 | [] | no_license | willrebuild/flyffsf | e5911fb412221e00a20a6867fd00c55afca593c7 | d38cc11790480d617b38bb5fc50729d676aef80d | refs/heads/master | 2021-01-19T20:27:35.200154 | 2011-02-10T12:34:43 | 2011-02-10T12:34:43 | 32,710,780 | 3 | 0 | null | null | null | null | UHC | C++ | false | false | 7,384 | h | // InstanceDungeonBase.h: interface for the CInstanceDungeonBase class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_INSTANCEDUNGEONBASE_H__5F92E1D4_2A9F_4602_8D26_35E328B9C160__INCLUDED_)
#define AFX_INSTANCEDUNGEONBASE_H__5F92E1D4_2A9F_4602_8D26_35E328B9C160__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#if __VER >= 14 // __INSTANCE_DUNGEON
#include "ar.h"
#ifdef __WORLDSERVER
#include "defineText.h"
#endif // __WORLDSERVER
enum { IDTYPE_SOLO=0, IDTYPE_PARTY, IDTYPE_GUILD, IDTYPE_MAX };
enum { ID_NORMAL=0, ID_MIDBOSS, ID_BOSS };
const WORD CLASS_NORMAL=0x0001, CLASS_MASTER=0x0002, CLASS_HERO=0x0004;
const int COOLTIMECOUNT = 10;
typedef struct INSTACNEDUNGEON_INFO
{
DWORD dwWorldId;
ULONG uMultiKey;
#ifdef __WORLDSERVER
int nState;
int nPlayerCount;
int nKillCount;
#endif // __WORLDSERVER
INSTACNEDUNGEON_INFO( DWORD dwWI, ULONG uMK ) : dwWorldId( dwWI ), uMultiKey( uMK )
#ifdef __WORLDSERVER
,nState( ID_NORMAL ), nPlayerCount( 0 ), nKillCount( 0 )
#endif // __WORLDSERVER
{}
void Serialize( CAr & ar )
{
if( ar.IsStoring() )
ar << dwWorldId << uMultiKey;
else
ar >> dwWorldId >> uMultiKey;
}
} ID_INFO;
typedef vector<ID_INFO> VEC_IDINFO;
typedef map<DWORD, VEC_IDINFO> MAP_IDBASE;
struct COOLTIME_INFO
{
DWORD dwWorldId;
DWORD dwDungeonId;
DWORD dwCoolTime;
COOLTIME_INFO() : dwWorldId( NULL_ID), dwDungeonId( NULL_ID ), dwCoolTime( 0 ) {}
COOLTIME_INFO( DWORD dwWI, DWORD dwDI, DWORD dwCT ) : dwWorldId( dwWI ), dwDungeonId( dwDI ), dwCoolTime( dwCT ) {}
void Serialize( CAr & ar )
{
if( ar.IsStoring() )
ar << dwWorldId << dwDungeonId << ( dwCoolTime - GetTickCount() );
else
{
ar >> dwWorldId >> dwDungeonId >> dwCoolTime;
dwCoolTime += GetTickCount();
}
}
};
typedef vector<COOLTIME_INFO> VEC_CTINFO;
typedef map<DWORD, VEC_CTINFO> MAP_CTINFO;
//////////////////////////////////////////////////////////////////////
// CInstanceDungeonBase
//////////////////////////////////////////////////////////////////////
class CInstanceDungeonBase
{
public:
CInstanceDungeonBase( int nIDType );
virtual ~CInstanceDungeonBase();
int GetType() { return m_nIDType; }
void SerializeAllInfo( CAr & ar );
BOOL CreateDungeon( ID_INFO ID_Info, DWORD dwDungeonId );
BOOL DestroyDungeon( ID_INFO ID_Info, DWORD dwDungeonId );
void DestroyAllDungeonByDungeonID( DWORD dwDungeonId );
void DestroyAllDungeonByMultiKey( ULONG uMultiKey ); //현재까지는 CoreServer만 사용.
void SetDungeonCoolTimeInfo( COOLTIME_INFO CT_Info, DWORD dwPlayerId );
void ResetDungeonCoolTimeInfo( DWORD dwWorldId, DWORD dwDungeonId );
private:
BOOL CreateDungeonLayer( ID_INFO & ID_Info, DWORD dwLayer );
BOOL DestroyDungeonLayer( ID_INFO & ID_Info, DWORD dwLayer );
VEC_IDINFO* GetDungeonVector( DWORD dwDungeonId );
ID_INFO* GetDungeonInfo( DWORD dwDungeonId, DWORD dwWorldId );
VEC_CTINFO* GetCoolTimeVector( DWORD dwPlayerId );
COOLTIME_INFO* GetCoolTimeInfo( DWORD dwPlayerId, DWORD dwWorldId );
int m_nIDType;
MAP_IDBASE m_mapID;
MAP_CTINFO m_mapCTInfo;
#ifdef __CORESERVER
public:
void DungeonCoolTimeCountProcess();
void UpdateDungeonCoolTimeInfo();
private:
int m_nCoolTimeCount;
#endif // __CORESERVER
#ifdef __WORLDSERVER
private:
struct DUNGEON_DATA
{
struct MONSTER
{
int nState;
DWORD dwMonsterId;
BOOL bRed;
D3DXVECTOR3 vPos;
};
DWORD dwClass;
int nMinLevel;
int nMaxLevel;
DWORD dwCoolTime;
map<int, D3DXVECTOR3> mapTeleportPos;
vector<MONSTER> vecMonster;
map<int, int> mapObjCount;
};
typedef map<DWORD, DUNGEON_DATA> MAP_IDDATA;
MAP_IDDATA m_mapDungeonData;
int GetState( DWORD dwWorldId, DWORD dwDungeonId );
void SetNextState( ID_INFO* pInfo, DWORD dwDungeonId );
D3DXVECTOR3 GetTeleportPos( DWORD dwWorldId, DWORD dwDungeonId );
BOOL CheckClassLevel( CUser* pUser, DWORD dwWorldId );
void CreateMonster( DWORD dwDungeonId, DWORD dwWorldId );
BOOL IsNowStateMonster( DWORD dwWorldId, DWORD dwDungeonId, DWORD dwMonsterId );
int GetObjCount( DWORD dwWorldId, DWORD dwDungeonId );
DWORD GetCoolTime( DWORD dwWorldId );
BOOL IncreasePlayerCount( DWORD dwDungeonId, DWORD dwWorldId );
BOOL DecreasePlayerCount( CUser* pUser, DWORD dwDungeonId, DWORD dwWorldId );
BYTE m_nMaxInstanceDungeon;
protected:
BOOL TeleportToDungeon( CUser* pUser, DWORD dwWorldId, DWORD dwDungeonId );
BOOL LeaveToOutside( CUser* pUser, DWORD dwWorldId, DWORD dwDungeonId );
void SetLeaveMarkingPos( CUser* pUser, DWORD dwWorldId, D3DXVECTOR3 vPos );
public:
void LoadScript( const char* szFileName );
virtual BOOL EnteranceDungeon( CUser* pUser, DWORD dwWorldId ) = FALSE;
virtual BOOL LeaveDungeon( CUser* pUser, DWORD dwWorldId ) = FALSE;
void SetInstanceDungeonKill( DWORD dwWorldId, DWORD dwDungeonId, DWORD dwMonsterId );
void DeleteDungeonCoolTimeInfo( DWORD dwPlayerId );
#endif // __WORLDSERVER
};
//////////////////////////////////////////////////////////////////////
// CInstanceDungeonHelper
//////////////////////////////////////////////////////////////////////
class CInstanceDungeonHelper
{
public:
CInstanceDungeonHelper();
~CInstanceDungeonHelper();
static CInstanceDungeonHelper* GetInstance();
void OnCreateDungeon( int nType, ID_INFO ID_Info, DWORD dwDungeonId );
void OnDestroyDungeon( int nType, ID_INFO ID_Info, DWORD dwDungeonId );
void OnSetDungeonCoolTimeInfo( ULONG uKey, int nType, COOLTIME_INFO CT_Info, DWORD dwPlayerId );
void OnResetDungeonCoolTimeInfo( int nType, DWORD dwWorldId, DWORD dwDungeonId );
void SendInstanceDungeonCreate( int nType, DWORD dwDungeonId, ID_INFO & ID_Info );
void SendInstanceDungeonDestroy( int nType, DWORD dwDungeonId, ID_INFO & ID_Info );
void SendInstanceDungeonSetCoolTimeInfo( ULONG uKey, int nType, DWORD dwPlayerId, COOLTIME_INFO & CT_Info );
void DestroyAllDungeonByMultiKey( ULONG uMultiKey );
private:
CInstanceDungeonBase* GetDungeonPtr( int nType );
typedef map<DWORD, int> MAP_WORLD2TYPE;
MAP_WORLD2TYPE m_mapDungeonType;
#ifdef __CORESERVER
public:
void SendInstanceDungeonAllInfo( DWORD dpId );
void SendInstanceDungeonDeleteCoolTimeInfo( int nType, DWORD dwPlayerId );
#endif // __CORESERVER
#ifdef __WORLDSERVER
public:
void OnInstanceDungeonAllInfo( CAr & ar );
BOOL IsDungeonType( DWORD dwWorldId, int nType ) { return GetType( dwWorldId ) == nType; }
BOOL IsInstanceDungeon( DWORD dwWorldId ) { return GetType( dwWorldId ) != NULL_ID; }
void SetDungeonType( DWORD dwWorldId, int nType );
BOOL EnteranceDungeon( CUser* pUser, DWORD dwWorldId );
BOOL LeaveDungeon( CUser* pUser, DWORD dwWorldId );
void GoOut( CUser* pUser );
void SetInstanceDungeonKill( DWORD dwWorldId, DWORD dwDungeonId, DWORD dwMonsterId );
void OnDeleteDungeonCoolTimeInfo( int nType, DWORD dwPlayerId );
BYTE m_nIDLayerNum;
private:
void SetCertifyKey( ULONG uMultiKey = NULL_ID );
BOOL IsCertifying() { return m_uCertifyKey != NULL_ID; }
int GetType( DWORD dwWorldId );
ULONG m_uCertifyKey;
#endif // __WORLDSERVER
};
#endif // __INSTANCE_DUNGEON
#endif // !defined(AFX_INSTANCEDUNGEONBASE_H__5F92E1D4_2A9F_4602_8D26_35E328B9C160__INCLUDED_)
| [
"[email protected]@e2c90bd7-ee55-cca0-76d2-bbf4e3699278"
] | [
[
[
1,
222
]
]
] |
99050d159edfb45148cc86549dc86c2c7187737b | a37df219b4a30e684db85b00dd76d4c36140f3c2 | /1.7.1/dbloader/view.cpp | 1be851981b887f3a1feb224a84c2cb30d90ac646 | [] | no_license | BlackMoon/bm-net | 0f79278f8709cd5d0738a6c3a27369726b0bb793 | eb6414bc412a8cfc5c24622977e7fa7203618269 | refs/heads/master | 2020-12-25T20:20:44.843483 | 2011-11-29T10:33:17 | 2011-11-29T10:33:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 919 | cpp | // view.cpp : implementation of the CChildView class
//
#include "stdafx.h"
#include "dbloader.h"
#include "view.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CChildView
CChildView::CChildView()
{
}
CChildView::~CChildView()
{
}
BEGIN_MESSAGE_MAP(CChildView, CWnd)
ON_WM_PAINT()
END_MESSAGE_MAP()
// CChildView message handlers
BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs)
{
if (!CWnd::PreCreateWindow(cs))
return FALSE;
cs.dwExStyle |= WS_EX_CLIENTEDGE;
cs.style &= ~WS_BORDER;
cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS,
::LoadCursor(NULL, IDC_ARROW), reinterpret_cast<HBRUSH>(COLOR_WINDOW+1), NULL);
return TRUE;
}
void CChildView::OnPaint()
{
CPaintDC dc(this); // device context for painting
// TODO: Add your message handler code here
// Do not call CWnd::OnPaint() for painting messages
}
| [
"[email protected]@b6168ec3-97fc-df6f-cbe5-288b4f99fbbd"
] | [
[
[
1,
53
]
]
] |
732a5cd75513717a5e926f4fe8a957e801484e39 | c1bcff0f1321de8a6425723cdfa0b5aa65b5c81f | /TransX/tags/3.13/shiplist.cpp | cd1e4da4fbc271cf5896262a28f595f4e6073bed | [
"MIT"
] | permissive | net-lisias-orbiter/transx | 560266e7a4ef73ed29d9004e406fd8db28da9a43 | b9297027718a7499934a9614430aebb47422ce7f | refs/heads/master | 2023-06-27T14:16:10.697238 | 2010-09-05T01:18:54 | 2010-09-05T01:18:54 | 390,398,358 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,342 | cpp | /* Copyright (c) 2007 Duncan Sharpe, Steve Arch
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
** THE SOFTWARE.*/
#define STRICT
#include <windows.h>
#include <stdio.h>
#include <math.h>
#include "orbitersdk.h"
#include "parser.h"
#include "mapfunction.h"
#include "shiplist.h"
class shipptrs* shipptrs::first=NULL;
class shipptrs* shipptrs::current=NULL;
bool shipptrs::saved=false;
shipptrs::shipptrs()
{
OBJHANDLE hcraft=oapiGetFocusObject();//Sets up new shipptrs for focus object
ZeroMemory(shipname, SHIPNAME_LENGTH);
oapiGetObjectName(hcraft,shipname,SHIPNAME_LENGTH - 1); // Why is this -1?
subcreate();
state=new transxstate(hcraft,this);//A new plan base for this vessel
}
shipptrs::shipptrs(OBJHANDLE hcraft)
{
ZeroMemory(shipname, SHIPNAME_LENGTH);
oapiGetObjectName(hcraft,shipname,SHIPNAME_LENGTH - 1);
state=new transxstate(hcraft,this);//A new plan base for this vessel
subcreate();
}
void shipptrs::subcreate()
{
previous=NULL;
for (int a=0;a<MFDLIST_LENGTH;a++)
mfdlist[a]=NULL;//No views yet
next=first;
first=this;
if (next!=NULL)next->previous=this;
}
shipptrs::~shipptrs()
{
for (int a=0;a<MFDLIST_LENGTH;a++)
delete mfdlist[a];
delete state;
if (first==this) first=next;
if (next!=NULL) next->previous=previous;
if (previous!=NULL) previous->next=next;
}
void shipptrs::backgroundaction()
{
class mapfunction *map=mapfunction::getthemap();
if (!map->getinitialised()) return;
if (current==NULL)
{
current=first;
if (current==NULL) return;
}
current->state->checkbasefunction();
current=current->next;
}
class shipptrs *shipptrs::findship(OBJHANDLE hcraft)
{
char tname[30];
oapiGetObjectName(hcraft,tname,30);
return findship(tname);
}
class shipptrs *shipptrs::findship(char *tname)
{
if (first==NULL) return NULL;
class shipptrs *ptr=first;
do
{
if (strcmp(ptr->shipname,tname)==0) return ptr;
ptr=ptr->next;
}
while (ptr!=NULL);
return NULL;
}
void shipptrs::saveallships(FILEHANDLE scn)
{
if (saved) return;
class shipptrs *current=first;
while (current!=NULL)
{
current->savecurrent(scn);
current=current->next;
}
saved=true;
}
void shipptrs::restoreallships(FILEHANDLE scn)
{
char *buffer,*member;
Parser parser;
int length;
while (oapiReadScenario_nextline(scn,buffer))
{
parser.parseline(buffer);
bool ok=parser.getlineelement(0,&member,&length);
if (!ok) return;
if (strcmp("Ship",member)==0)
{
if (!parser.getlineelement(1,&member,&length)) return;//return if ship label doesn't exist
if (length>30) return;//return if ship label is bad
class shipptrs *temp=findship(member);
if (temp==NULL)
{
OBJHANDLE temphandle=oapiGetVesselByName(member);
if (temphandle!=NULL) temp=new shipptrs(temphandle);
}
if (temp!=NULL) temp->restorecurrent(scn);
}
}
}
void shipptrs::savecurrent(FILEHANDLE scn)
{
oapiWriteScenario_string(scn,"Ship ",shipname);
state->savecurrent(scn);
}
void shipptrs::restorecurrent(FILEHANDLE scn)
{
state->restoresave(scn);
}
class shipptrs *shipptrs::getshipptrs()
{
OBJHANDLE hcraft=oapiGetFocusObject();
class shipptrs *ptr=findship(hcraft);
if (ptr==NULL)
ptr=new shipptrs();
return ptr;
}
void shipptrs::destroyshipptrs()
{
current=NULL;
while (first!=NULL)
{
class shipptrs *temp=first;
delete temp;//Destructor modifies first
}
//Also destroys the map
class mapfunction *map=mapfunction::getthemap();
if (map!=NULL)
delete map;
}
void shipptrs::downshift()
{
for (int a=0; a<MFDLIST_LENGTH; a++)
if (mfdlist[a]!=NULL) mfdlist[a]->selfdownshift();
}
void shipptrs::resetshift()
{
for (int a=0;a<MFDLIST_LENGTH;a++)
if (mfdlist[a]!=NULL) mfdlist[a]->resetshift();
}
class viewstate *shipptrs::getviewstate(int mfdpos,class TransxMFD *mfdptr)
{
if (mfdpos<0 || mfdpos>MFDLIST_LENGTH - 1) mfdpos=0;
if (mfdlist[mfdpos]==NULL)
mfdlist[mfdpos]=new viewstate(mfdpos,this);
return mfdlist[mfdpos];
}
class shipptrs* shipptr_itr::getnext()
{
if (current!=NULL) current=current->next;
return current;
}
class shipptrs* shipptr_itr::getprev()
{
if (current!=NULL) current=current->previous;
return current;
} | [
"steve@5a6c10e1-6920-0410-8c7b-9669c677a970"
] | [
[
[
1,
208
]
]
] |
463a4451120f90379f6ed5666e52c6b812d7fc35 | f4e20d6ad5d3a6ef3406d66d3eb4bb1fdc6c1088 | /CarMP_OpenGL/OpenGLManager.h | 19b96efe2f2cefb251b8adbd92f7bfde505173aa | [] | no_license | WildGenie/carmp | c19cfbac3dda7dfcdc6ca7de8c0fb274e07efe5b | 7d1e41acabbafa87298de745563a16b9ce7cd9b0 | refs/heads/master | 2021-01-12T07:31:33.858240 | 2011-10-05T23:31:31 | 2011-10-05T23:31:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,793 | h | #pragma once
//#include "vld.h"
#include "GLResourceBase.h"
#include "Shader.h"
#include "OGLTexture.h"
#include "OGLTextLayout.h"
#include <stack>
// End OpenGL Includes
using namespace std;
typedef struct OGL_MOUSE_EVENT {
float x;
float y;
};
class OpenGLManager
{
private:
void (__stdcall *m_mouseMoveHandler)(sf::Event::MouseMoveEvent);
void (__stdcall *m_mouseUpHandler)(sf::Event::MouseButtonEvent);
void (__stdcall *m_mouseDownHandler)(sf::Event::MouseButtonEvent);
void (__stdcall *m_keyboardHandler)(sf::Event::KeyEvent);
void (__stdcall *m_windowCloseHandler)(void);
static OpenGLManager* _instance;
const OpenGLManager& operator=(const OpenGLManager& a);
OpenGLManager(void);
OpenGLManager(OpenGLManager const&); // Don't Implement
// void operator=(OpenGLManager const&); // Don't implement
~OpenGLManager(void);
stack<OGL_RECT> clippingStack;
sf::RenderWindow* renderer;
sf::Thread* eventThread;
OGL_RECT m_currentWindowBounds;
void ApplyGlScissor(OGL_RECT);
void ProcessEventThread(void);
bool m_shutDownThread;
public:
void CreateOGLWindow(const OGL_RECT& pScreen);
// Drawing methods:
void DrawImage(OGLTexture* pTexture, const OGL_RECT& pRectangle, float pAlpha);
void DrawRectangle(const OGL_COLOR& pBrush, const OGL_RECT& pRect, float pLineWidth);
void FillRectangle(const OGL_COLOR&, const OGL_RECT&);
void DrawEllipse(const OGL_ELLIPSE&, const OGL_COLOR&, float pLineWidth);
void DrawLine(const OGL_POINT& pPoint1, const OGL_POINT& pPoint2, const OGL_COLOR& pBrush, float pLineWidth);
void FillEllipse(const OGL_ELLIPSE&, const OGL_COLOR&);
void DrawText(OGLTextLayout* pTextLayout, const OGL_RECT& pRectangle, const OGL_COLOR& pColor);
void Clear(const OGL_COLOR& pBrush);
void DisplayBuffer(void);
// Resource Methods:
OGLTextLayout* OpenGLManager::CreateTextLayout(const char* pString, const char* pFont, float pSize, int pAlignment);
void OpenGLManager::FreeTextLayout(OGLTextLayout*);
OGLTexture* CreateImage(const char* pPath);
OGLTexture* CreateImageFromByteArray(const char* pByteArray, int pStride);
void FreeImage(OGLTexture* pTexture);
//void DrawImage(Rectangle pRectangle, IImage pImage, float pAlpha);
void RegisterMouseMoveCallback(void (__stdcall *)(sf::Event::MouseMoveEvent));
void RegisterMouseDownCallback(void (__stdcall *)(sf::Event::MouseButtonEvent));
void RegisterMouseUpCallback(void (__stdcall *)(sf::Event::MouseButtonEvent));
void RegisterKeyboardCallback(void (__stdcall *)(sf::Event::KeyEvent));
void RegisterWindowCloseCallback(void (__stdcall *)(void));
static OpenGLManager* GetInstance(void);
void TestFunction(void);
void PushClip(OGL_RECT);
void PopClip();
};
| [
"efess@d4bd84e2-f980-fb58-ec8a-1c4e3f86fd2c",
"[email protected]@d4bd84e2-f980-fb58-ec8a-1c4e3f86fd2c"
] | [
[
[
1,
2
],
[
4,
5
],
[
8,
8
],
[
10,
13
],
[
15,
21
],
[
27,
35
],
[
45,
45
],
[
47,
48
],
[
67,
68
],
[
75,
77
],
[
81,
82
]
],
[
[
3,
3
],
[
6,
7
],
[
9,
9
],
[
14,
14
],
[
22,
26
],
[
36,
44
],
[
46,
46
],
[
49,
66
],
[
69,
74
],
[
78,
80
]
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.